diff --git a/.cargo/config.toml b/.cargo/config.toml
index 0e465b2d..8db457df 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -1,2 +1,4 @@
-[target.wasm32-unknown-unknown]
-rustflags = ["--cfg", "getrandom_backend=\"wasm_js\""]
+[env]
+TS_RS_EXPORT_DIR = { value = "ui/src/generated", relative = true }
+TS_RS_IMPORT_EXTENSION = "ts"
+TS_RS_LARGE_INT = "number"
diff --git a/.github/actions/setup/action.yml b/.github/actions/setup/action.yml
new file mode 100644
index 00000000..c914319f
--- /dev/null
+++ b/.github/actions/setup/action.yml
@@ -0,0 +1,37 @@
+name: Set up Gate
+description: Check out the pinned Hellas workspace and load Gate's locked development tools
+runs:
+  using: composite
+  steps:
+    - name: Read Hellas revision
+      id: hellas
+      shell: bash
+      working-directory: ${{ github.workspace }}/gate
+      run: |
+        revision=$(<.hellas-revision)
+        if [[ ! "$revision" =~ ^[0-9a-f]{40}$ ]]; then
+          echo "::error::.hellas-revision must contain one full commit SHA"
+          exit 1
+        fi
+        printf 'revision=%s\n' "$revision" >> "$GITHUB_OUTPUT"
+
+    - name: Check out Hellas
+      uses: actions/checkout@v5
+      with:
+        repository: hellas-ai/hellas
+        ref: ${{ steps.hellas.outputs.revision }}
+        path: hellas
+        persist-credentials: false
+
+    - name: Install Nix
+      uses: cachix/install-nix-action@v31
+      with:
+        github_access_token: ${{ github.token }}
+
+    - name: Cache Rust dependencies
+      uses: Swatinem/rust-cache@v2
+      with:
+        workspaces: gate -> target
+        key: ${{ runner.arch }}-${{ hashFiles('gate/flake.lock', 'gate/.hellas-revision') }}
+        cache-bin: false
+        cmd-format: nix develop --no-update-lock-file "${{ github.workspace }}/gate" --command {0}
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
deleted file mode 100644
index 2406f094..00000000
--- a/.github/dependabot.yml
+++ /dev/null
@@ -1,12 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "cargo"
-    directory: "/"
-    schedule:
-      interval: "daily"
-    open-pull-requests-limit: 10
-    
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"
\ No newline at end of file
diff --git a/.github/scripts/macos-keychain.sh b/.github/scripts/macos-keychain.sh
new file mode 100644
index 00000000..b851fc05
--- /dev/null
+++ b/.github/scripts/macos-keychain.sh
@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+: "${RUNNER_TEMP:?This script requires a GitHub Actions runner}"
+keychain="$RUNNER_TEMP/gate-signing.keychain-db"
+certificate="$RUNNER_TEMP/gate-signing.p12"
+search_list="$RUNNER_TEMP/gate-keychain-search-list.txt"
+
+case "${1:-}" in
+  setup)
+    : "${APPLE_CERTIFICATE:?Missing APPLE_CERTIFICATE}"
+    : "${APPLE_CERTIFICATE_PASSWORD:?Missing APPLE_CERTIFICATE_PASSWORD}"
+    : "${APPLE_SIGNING_IDENTITY:?Missing APPLE_SIGNING_IDENTITY}"
+    : "${KEYCHAIN_PASSWORD:?Missing KEYCHAIN_PASSWORD}"
+    if [[ "$APPLE_SIGNING_IDENTITY" != "Developer ID Application:"* &&
+          ! "$APPLE_SIGNING_IDENTITY" =~ ^[0-9A-Fa-f]{40}$ ]]; then
+      echo "APPLE_SIGNING_IDENTITY must be a Developer ID Application name or certificate SHA-1" >&2
+      exit 1
+    fi
+    umask 077
+    /usr/bin/security list-keychains -d user > "$search_list"
+    printf '%s' "$APPLE_CERTIFICATE" | /usr/bin/base64 --decode > "$certificate"
+    /usr/bin/security create-keychain -p "$KEYCHAIN_PASSWORD" "$keychain"
+    /usr/bin/security set-keychain-settings -lut 21600 "$keychain"
+    /usr/bin/security unlock-keychain -p "$KEYCHAIN_PASSWORD" "$keychain"
+    /usr/bin/security import "$certificate" -P "$APPLE_CERTIFICATE_PASSWORD" \
+      -k "$keychain" -t cert -f pkcs12 -T /usr/bin/codesign
+    /usr/bin/security set-key-partition-list -S apple-tool:,apple:,codesign: \
+      -s -k "$KEYCHAIN_PASSWORD" "$keychain"
+    keychains=("$keychain")
+    while IFS= read -r previous; do
+      keychains+=("$previous")
+    done < <(sed -E 's/^[[:space:]]*"//; s/"[[:space:]]*$//' "$search_list")
+    /usr/bin/security list-keychains -d user -s "${keychains[@]}"
+    /usr/bin/security find-identity -v -p codesigning "$keychain"
+    rm -f "$certificate"
+    ;;
+  cleanup)
+    if [[ -f "$search_list" ]]; then
+      keychains=()
+      while IFS= read -r previous; do
+        keychains+=("$previous")
+      done < <(sed -E 's/^[[:space:]]*"//; s/"[[:space:]]*$//' "$search_list")
+      /usr/bin/security list-keychains -d user -s "${keychains[@]}"
+    fi
+    if [[ -f "$keychain" ]]; then
+      /usr/bin/security delete-keychain "$keychain"
+    fi
+    rm -f "$certificate"
+    ;;
+  *)
+    echo "Usage: macos-keychain.sh setup|cleanup" >&2
+    exit 1
+    ;;
+esac
diff --git a/.github/scripts/package-macos-release.sh b/.github/scripts/package-macos-release.sh
new file mode 100644
index 00000000..adab8673
--- /dev/null
+++ b/.github/scripts/package-macos-release.sh
@@ -0,0 +1,77 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+: "${CARGO_TARGET_DIR:?Missing CARGO_TARGET_DIR}"
+: "${RUNNER_TEMP:?This script requires a GitHub Actions runner}"
+: "${APPLE_SIGNING_IDENTITY:?Missing APPLE_SIGNING_IDENTITY}"
+: "${APPLE_ID:?Missing APPLE_ID}"
+: "${APPLE_PASSWORD:?Missing APPLE_PASSWORD}"
+: "${APPLE_TEAM_ID:?Missing APPLE_TEAM_ID}"
+: "${GITHUB_REF_NAME:?Missing release tag}"
+
+version=$(python3 .github/scripts/release-version.py "$GITHUB_REF_NAME")
+app="$CARGO_TARGET_DIR/aarch64-apple-darwin/release/bundle/macos/Hellas Gate.app"
+release_dir=$(mktemp -d "$RUNNER_TEMP/gate-release.XXXXXX")
+staging=$(mktemp -d "$RUNNER_TEMP/gate-dmg.XXXXXX")
+mountpoint=$(mktemp -d "$RUNNER_TEMP/gate-mount.XXXXXX")
+extraction=$(mktemp -d "$RUNNER_TEMP/gate-zip.XXXXXX")
+archive="$release_dir/Hellas-Gate_${version}_aarch64.app.zip"
+dmg="$release_dir/Hellas-Gate_${version}_aarch64.dmg"
+mounted=false
+
+cleanup() {
+  if [[ "$mounted" == true ]]; then
+    /usr/bin/hdiutil detach "$mountpoint" || true
+  fi
+}
+trap cleanup EXIT
+
+notarize() {
+  local artifact=$1
+  local report=$2
+  if ! /usr/bin/xcrun notarytool submit "$artifact" \
+    --apple-id "$APPLE_ID" --password "$APPLE_PASSWORD" --team-id "$APPLE_TEAM_ID" \
+    --wait --timeout 30m --output-format json > "$report"; then
+    cat "$report"
+    return 1
+  fi
+  cat "$report"
+  if [[ "$(/usr/bin/plutil -extract status raw -o - "$report")" != Accepted ]]; then
+    local submission
+    submission=$(/usr/bin/plutil -extract id raw -o - "$report")
+    /usr/bin/xcrun notarytool log "$submission" \
+      --apple-id "$APPLE_ID" --password "$APPLE_PASSWORD" --team-id "$APPLE_TEAM_ID" || true
+    return 1
+  fi
+}
+
+bash .github/scripts/verify-macos-app.sh "$app"
+/usr/bin/ditto -c -k --sequesterRsrc --keepParent "$app" "$archive"
+notarize "$archive" "$release_dir/app-notarization.json"
+/usr/bin/xcrun stapler staple "$app"
+bash .github/scripts/verify-macos-app.sh "$app" --notarized
+
+# Build the disk image from the stapled app so both delivery formats work offline.
+/usr/bin/ditto "$app" "$staging/Hellas Gate.app"
+ln -s /Applications "$staging/Applications"
+/usr/bin/hdiutil create -volname 'Hellas Gate' -srcfolder "$staging" -format UDZO "$dmg"
+/usr/bin/codesign --force --sign "$APPLE_SIGNING_IDENTITY" --timestamp "$dmg"
+/usr/bin/codesign --verify --strict --verbose=2 "$dmg"
+notarize "$dmg" "$release_dir/dmg-notarization.json"
+/usr/bin/xcrun stapler staple "$dmg"
+/usr/bin/xcrun stapler validate "$dmg"
+/usr/sbin/spctl --assess --type open --context context:primary-signature --verbose=2 "$dmg"
+/usr/bin/hdiutil verify "$dmg"
+/usr/bin/hdiutil attach "$dmg" -readonly -nobrowse -mountpoint "$mountpoint"
+mounted=true
+bash .github/scripts/verify-macos-app.sh "$mountpoint/Hellas Gate.app" --notarized
+/usr/bin/hdiutil detach "$mountpoint"
+mounted=false
+
+# Recreate the zip after stapling; ditto preserves executable modes and symlinks.
+/usr/bin/ditto -c -k --sequesterRsrc --keepParent "$app" "$archive"
+/usr/bin/ditto -x -k "$archive" "$extraction"
+bash .github/scripts/verify-macos-app.sh "$extraction/Hellas Gate.app" --notarized
+test -s "$dmg"
+test -s "$archive"
+printf 'GATE_RELEASE_DIR=%s\n' "$release_dir" >> "$GITHUB_ENV"
diff --git a/.github/scripts/release-version.py b/.github/scripts/release-version.py
new file mode 100644
index 00000000..bbd4da7c
--- /dev/null
+++ b/.github/scripts/release-version.py
@@ -0,0 +1,26 @@
+"""Validate Cargo/Tauri version agreement, and optionally the release tag."""
+
+import json
+import re
+import sys
+import tomllib
+from pathlib import Path
+
+root = Path(__file__).resolve().parents[2]
+workspace = tomllib.loads((root / "Cargo.toml").read_text())
+package = tomllib.loads((root / "src-tauri/Cargo.toml").read_text())["package"]
+config = json.loads((root / "src-tauri/tauri.conf.json").read_text())
+version = workspace["workspace"]["package"]["version"]
+package_version = package["version"]
+if package_version == {"workspace": True}:
+    package_version = version
+
+if not re.fullmatch(r"\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?", version):
+    sys.exit(f"Invalid release version: {version}")
+if config["version"] != version or package_version != version:
+    sys.exit("Cargo workspace, desktop package, and Tauri versions must agree")
+if len(sys.argv) > 2:
+    sys.exit("Usage: release-version.py [vVERSION]")
+if len(sys.argv) == 2 and sys.argv[1] != f"v{version}":
+    sys.exit(f"Release tag must be v{version}, got {sys.argv[1]}")
+print(version)
diff --git a/.github/scripts/verify-macos-app.sh b/.github/scripts/verify-macos-app.sh
new file mode 100644
index 00000000..0ab3423f
--- /dev/null
+++ b/.github/scripts/verify-macos-app.sh
@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+app=${1:?Usage: verify-macos-app.sh APP [--notarized]}
+version=$(python3 .github/scripts/release-version.py)
+plist="$app/Contents/Info.plist"
+test -f "$plist"
+[[ "$(/usr/libexec/PlistBuddy -c 'Print :CFBundleIdentifier' "$plist")" == ai.hellas.gate ]]
+[[ "$(/usr/libexec/PlistBuddy -c 'Print :CFBundleShortVersionString' "$plist")" == "$version" ]]
+executable=$(/usr/libexec/PlistBuddy -c 'Print :CFBundleExecutable' "$plist")
+test -x "$app/Contents/MacOS/$executable"
+[[ "$(/usr/bin/lipo -archs "$app/Contents/MacOS/$executable")" == arm64 ]]
+/usr/bin/codesign --verify --deep --strict --verbose=2 "$app"
+
+if [[ "${2:-}" == --notarized ]]; then
+  : "${APPLE_TEAM_ID:?APPLE_TEAM_ID is required to verify a release}"
+  details=$(/usr/bin/codesign --display --verbose=4 "$app" 2>&1)
+  printf '%s\n' "$details"
+  printf '%s\n' "$details" | grep -q '^Authority=Developer ID Application:'
+  printf '%s\n' "$details" | grep -Fqx "TeamIdentifier=$APPLE_TEAM_ID"
+  printf '%s\n' "$details" | grep -Eq '^CodeDirectory .*flags=.*runtime'
+  /usr/bin/xcrun stapler validate "$app"
+  /usr/sbin/spctl --assess --type execute --verbose=2 "$app"
+fi
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 0b9291a2..c2be0089 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -2,239 +2,96 @@ name: CI
 
 on:
   push:
-    branches: [ master ]
+    branches: [master]
   pull_request:
-    branches: [ master ]
+    branches: [master]
+  merge_group:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ci-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
 
 env:
   CARGO_TERM_COLOR: always
+  CARGO_TARGET_DIR: ${{ github.workspace }}/gate/target
   RUST_BACKTRACE: 1
 
+defaults:
+  run:
+    shell: bash
+    working-directory: gate
+
 jobs:
-  test:
-    name: Test
-    runs-on: ubuntu-latest
+  linux:
+    name: Linux checks
+    runs-on: ubuntu-24.04
+    timeout-minutes: 90
     steps:
-    - uses: actions/checkout@v5
-    - uses: mkroening/rust-toolchain-toml@main
-    - uses: Swatinem/rust-cache@v2
+      - uses: actions/checkout@v5
+        with:
+          path: gate
+          persist-credentials: false
+      - uses: ./gate/.github/actions/setup
 
-    # Linux-specific dependencies
-    - name: Install Linux dependencies
-      if: runner.os == 'Linux'
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev clang xdg-utils
+      - name: Check formatting
+        run: nix develop --no-update-lock-file --command cargo fmt --all -- --check
 
-    - name: Check formatting
-      run: cargo fmt --all -- --check
-    
-    - name: Clippy
-      run: cargo clippy --workspace --all-features -- -D warnings
-    
-    - name: Build
-      run: cargo build --all-features
-    
-    - name: Test
-      run: cargo test --all-features
-  
-  gui-build:
-    name: GUI Build
-    needs: test
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: ubuntu-latest
-            target: x86_64-unknown-linux-gnu
-          - os: macos-latest
-            target: x86_64-apple-darwin
-          - os: macos-latest
-            target: aarch64-apple-darwin
-          - os: windows-latest
-            target: x86_64-pc-windows-msvc
-    steps:
-    - uses: actions/checkout@v5
-    
-    # Install Rust toolchain
-    - uses: mkroening/rust-toolchain-toml@main
-    - uses: Swatinem/rust-cache@v2
-    
-    # Import Apple certificate for macOS builds
-    - name: Import Apple Certificate
-      if: runner.os == 'macOS' && github.event_name != 'pull_request'
-      env:
-        APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
-        APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
-        KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}
-      run: |
-        # Create variables
-        CERTIFICATE_PATH=$RUNNER_TEMP/build_certificate.p12
-        KEYCHAIN_PATH=$RUNNER_TEMP/app-signing.keychain-db
-        
-        # Import certificate from secrets
-        echo -n "$APPLE_CERTIFICATE" | base64 --decode -o $CERTIFICATE_PATH
-        
-        # Create temporary keychain
-        security create-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
-        security set-keychain-settings -lut 21600 $KEYCHAIN_PATH
-        security unlock-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
-        
-        # Import certificate to keychain
-        security import $CERTIFICATE_PATH -P "$APPLE_CERTIFICATE_PASSWORD" -A -t cert -f pkcs12 -k $KEYCHAIN_PATH
-        security set-key-partition-list -S apple-tool:,apple: -k "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
-        security list-keychain -d user -s $KEYCHAIN_PATH
-    
-    # Add WASM target
-    - name: Add WASM target
-      run: rustup target add wasm32-unknown-unknown
-    
-    # Cache cargo-installed tools
-    - name: Cache cargo tools
-      uses: actions/cache@v4
-      with:
-        path: ~/.cargo/bin
-        key: ${{ runner.os }}-cargo-tools-trunk-tauri-${{ hashFiles('**/Cargo.lock') }}
-        restore-keys: |
-          ${{ runner.os }}-cargo-tools-trunk-tauri-
-          ${{ runner.os }}-cargo-tools-
-    
-    # Install build tools
-    - name: Install build tools
-      shell: bash
-      run: |
-        # Check if trunk is already installed
-        if ! command -v trunk &> /dev/null; then
-          echo "Installing trunk..."
-          cargo install trunk --locked
-        else
-          echo "trunk is already installed"
-        fi
-        
-        # Check if tauri is already installed
-        if ! command -v cargo-tauri &> /dev/null; then
-          echo "Installing tauri-cli..."
-          cargo install tauri-cli --locked
-        else
-          echo "tauri-cli is already installed"
-        fi
-    
-    # Install tailwindcss standalone CLI
-    - name: Install tailwindcss
-      shell: bash
-      run: |
-        # Map runner OS and arch to tailwind binary names
-        case "${{ runner.os }}-${{ runner.arch }}" in
-          "Linux-X64") BINARY="tailwindcss-linux-x64"; DEST="/usr/local/bin/tailwindcss" ;;
-          "macOS-X64") BINARY="tailwindcss-macos-x64"; DEST="/usr/local/bin/tailwindcss" ;;
-          "macOS-ARM64") BINARY="tailwindcss-macos-arm64"; DEST="/usr/local/bin/tailwindcss" ;;
-          "Windows-X64") BINARY="tailwindcss-windows-x64.exe"; DEST="$HOME/.cargo/bin/tailwindcss.exe" ;;
-        esac
-        
-        echo "Installing $BINARY to $DEST"
-        curl -sL "https://github.com/tailwindlabs/tailwindcss/releases/download/v4.1.11/${BINARY}" -o "$DEST"
-        chmod +x "$DEST"
-    
-    # Linux-specific dependencies
-    - name: Install Linux dependencies
-      if: runner.os == 'Linux'
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev clang xdg-utils
-    
-    # Windows-specific dependencies
-    - name: Install Windows dependencies
-      if: runner.os == 'Windows'
-      shell: cmd
-      run: |
-        vcpkg install openssl:x64-windows-static
-        vcpkg install openssl:x64-windows-static-md
-        vcpkg integrate install
-    
-    # Build frontends and GUI (without signing for PRs)
-    - name: Build GUI
-      if: github.event_name == 'pull_request'
-      env:
-        OPENSSL_STATIC: 1
-      run: cd crates/gui && cargo tauri build
-    
-    # Build frontends and GUI with signing (for pushes to master)
-    - name: Build GUI and Sign
-      if: github.event_name != 'pull_request'
-      env:
-        OPENSSL_STATIC: 1
-        APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
-        APPLE_ID: ${{ secrets.APPLE_ID }}
-        APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
-        APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
-      run: cd crates/gui && cargo tauri build
+      - name: Clippy
+        run: nix develop --no-update-lock-file --command cargo clippy --locked --workspace --all-targets --all-features -- -D warnings
 
-    # Notarize macOS app
-    - name: Notarize macOS App
-      if: runner.os == 'macOS' && github.event_name != 'pull_request'
-      env:
-        APPLE_ID: ${{ secrets.APPLE_ID }}
-        APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
-        APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
-      run: |
-        # Find the DMG file
-        DMG_FILE=$(find target/release/bundle/dmg -name "*.dmg" | head -1)
+      - name: Rust tests
+        run: nix develop --no-update-lock-file --command cargo test --locked --workspace --all-features
 
-        if [ -n "$DMG_FILE" ]; then
-          echo "Notarizing $DMG_FILE..."
+      - name: Generate and check TypeScript bindings
+        run: |
+          rm -f -- ui/src/generated/*.ts
+          nix develop --no-update-lock-file --command make bindings
+          changes=$(git status --porcelain --untracked-files=all -- ui/src/generated)
+          if [[ -n "$changes" ]]; then
+            printf '%s\n' "$changes"
+            git diff -- ui/src/generated
+            echo "::error::Generated bindings are stale; run make bindings and commit the result"
+            exit 1
+          fi
 
-          # Submit for notarization
-          xcrun notarytool submit "$DMG_FILE" \
-            --apple-id "$APPLE_ID" \
-            --password "$APPLE_PASSWORD" \
-            --team-id "$APPLE_TEAM_ID" \
-            --wait
+      - name: Typecheck and build frontend
+        run: nix develop --no-update-lock-file --command make ui-build
 
-          # Staple the notarization ticket
-          xcrun stapler staple "$DMG_FILE"
+  macos:
+    name: macOS ARM64 app
+    runs-on: macos-15
+    timeout-minutes: 120
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          path: gate
+          persist-credentials: false
+      - uses: ./gate/.github/actions/setup
 
-          echo "Notarization complete!"
-        else
-          echo "No DMG file found"
-          exit 1
-        fi
+      - name: Build app
+        env:
+          APPLE_SIGNING_IDENTITY: '-'
+        run: nix develop --no-update-lock-file --command cargo tauri build --target aarch64-apple-darwin --bundles app -- --locked
 
-    - name: Find and prepare artifacts
-      shell: bash
-      run: |
-        mkdir -p artifacts
-        
-        # Tauri outputs to target/release/bundle
-        if [[ "${{ runner.os }}" == "macOS" ]]; then
-          # macOS: Look for DMG and app bundles
-          if [[ -d "target/release/bundle" ]]; then
-            echo "Found macOS bundles"
-            cp -r target/release/bundle/dmg/*.dmg artifacts/ 2>/dev/null || true
-            cp -r target/release/bundle/macos/*.app artifacts/ 2>/dev/null || true
-          fi
-        elif [[ "${{ runner.os }}" == "Linux" ]]; then
-          # Linux: Look for deb and AppImage files
-          if [[ -d "target/release/bundle" ]]; then
-            echo "Found Linux bundles"
-            cp -r target/release/bundle/deb/*.deb artifacts/ 2>/dev/null || true
-            cp -r target/release/bundle/appimage/*.AppImage artifacts/ 2>/dev/null || true
-          fi
-        elif [[ "${{ runner.os }}" == "Windows" ]]; then
-          # Windows: Look for MSI files
-          if [[ -d "target/release/bundle" ]]; then
-            echo "Found Windows bundles"
-            cp -r target/release/bundle/msi/*.msi artifacts/ 2>/dev/null || true
-          fi
-        fi
-        
-        # List what we found
-        echo "Artifacts found:"
-        ls -la artifacts/ || echo "No artifacts directory"
-    
-    - name: Upload artifacts
-      uses: actions/upload-artifact@v4
-      with:
-        name: gate-gui-${{ matrix.target }}
-        path: artifacts/*
-        if-no-files-found: warn
+      - name: Validate app bundle
+        run: bash .github/scripts/verify-macos-app.sh "$CARGO_TARGET_DIR/aarch64-apple-darwin/release/bundle/macos/Hellas Gate.app"
+
+  ci:
+    name: CI
+    if: ${{ always() }}
+    needs: [linux, macos]
+    runs-on: ubuntu-24.04
+    timeout-minutes: 5
+    steps:
+      - name: Require every check to pass
+        working-directory: .
+        env:
+          LINUX_RESULT: ${{ needs.linux.result }}
+          MACOS_RESULT: ${{ needs.macos.result }}
+        run: |
+          printf 'Linux: %s\nmacOS: %s\n' "$LINUX_RESULT" "$MACOS_RESULT"
+          [[ "$LINUX_RESULT" == success && "$MACOS_RESULT" == success ]]
diff --git a/.github/workflows/dependabot-auto-merge.yml b/.github/workflows/dependabot-auto-merge.yml
deleted file mode 100644
index aa431799..00000000
--- a/.github/workflows/dependabot-auto-merge.yml
+++ /dev/null
@@ -1,28 +0,0 @@
-name: Dependabot auto-merge
-on: pull_request
-
-permissions:
-  contents: write
-  pull-requests: write
-
-jobs:
-  dependabot:
-    runs-on: ubuntu-latest
-    if: github.actor == 'dependabot[bot]'
-    steps:
-      - name: Dependabot metadata
-        id: metadata
-        uses: dependabot/fetch-metadata@v2
-        with:
-          github-token: "${{ secrets.GITHUB_TOKEN }}"
-      
-      - name: Enable auto-merge for Dependabot PRs
-        if: |
-          steps.metadata.outputs.update-type == 'version-update:semver-patch' ||
-          steps.metadata.outputs.update-type == 'version-update:semver-minor'
-        run: |
-          echo "Enabling auto-merge for ${{ steps.metadata.outputs.update-type }} update"
-          gh pr merge --auto --squash "$PR_URL"
-        env:
-          PR_URL: ${{github.event.pull_request.html_url}}
-          GH_TOKEN: ${{secrets.GITHUB_TOKEN}}
\ No newline at end of file
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 00000000..ccae49e2
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,84 @@
+name: Release macOS app
+
+on:
+  push:
+    tags: ['v*']
+
+permissions:
+  contents: read
+
+concurrency:
+  group: release-${{ github.ref }}
+  cancel-in-progress: false
+
+env:
+  CARGO_TERM_COLOR: always
+  CARGO_TARGET_DIR: ${{ github.workspace }}/gate/target
+  RUST_BACKTRACE: 1
+
+defaults:
+  run:
+    shell: bash
+    working-directory: gate
+
+jobs:
+  release:
+    name: Signed macOS ARM64 release
+    runs-on: macos-15
+    timeout-minutes: 150
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          path: gate
+          persist-credentials: false
+
+      - name: Validate release version
+        run: python3 .github/scripts/release-version.py "$GITHUB_REF_NAME"
+
+      - uses: ./gate/.github/actions/setup
+
+      - name: Import Developer ID certificate
+        env:
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
+          KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}
+        run: bash .github/scripts/macos-keychain.sh setup
+
+      - name: Build signed app
+        env:
+          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
+        run: nix develop --no-update-lock-file --command cargo tauri build --target aarch64-apple-darwin --bundles app -- --locked
+
+      - name: Notarize and package app and DMG
+        env:
+          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+        run: bash .github/scripts/package-macos-release.sh
+
+      - name: Publish release assets
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          version=$(python3 .github/scripts/release-version.py "$GITHUB_REF_NAME")
+          dmg="$GATE_RELEASE_DIR/Hellas-Gate_${version}_aarch64.dmg"
+          archive="$GATE_RELEASE_DIR/Hellas-Gate_${version}_aarch64.app.zip"
+          test -s "$dmg"
+          test -s "$archive"
+          if gh release view "$GITHUB_REF_NAME" --repo "$GITHUB_REPOSITORY" >/dev/null 2>&1; then
+            gh release upload "$GITHUB_REF_NAME" "$dmg" "$archive" --repo "$GITHUB_REPOSITORY" --clobber
+          else
+            flags=()
+            if [[ "$version" == *-* ]]; then flags+=(--prerelease); fi
+            gh release create "$GITHUB_REF_NAME" "$dmg" "$archive" \
+              --repo "$GITHUB_REPOSITORY" --verify-tag --generate-notes \
+              --title "Hellas Gate $GITHUB_REF_NAME" "${flags[@]}"
+          fi
+
+      - name: Remove signing credentials
+        if: ${{ always() }}
+        run: bash .github/scripts/macos-keychain.sh cleanup
diff --git a/.github/workflows/update-flake.yml b/.github/workflows/update-flake.yml
deleted file mode 100644
index d511bf4f..00000000
--- a/.github/workflows/update-flake.yml
+++ /dev/null
@@ -1,51 +0,0 @@
-name: Update Flake
-
-on:
-  schedule:
-    # Run daily at 3:00 UTC
-    - cron: '0 3 * * *'
-  workflow_dispatch:
-
-jobs:
-  update-flake:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v5
-      with:
-        token: ${{ secrets.GITHUB_TOKEN }}
-    
-    - uses: cachix/install-nix-action@v31
-      with:
-        github_access_token: ${{ secrets.GITHUB_TOKEN }}
-    
-    - name: Configure Git
-      run: |
-        git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
-        git config --global user.name "github-actions[bot]"
-    
-    - name: Update flake inputs
-      run: |
-        nix flake update --commit-lock-file
-    
-    - name: Check if updates were made
-      id: check-updates
-      run: |
-        if git diff --quiet HEAD~1 HEAD -- flake.lock; then
-          echo "updated=false" >> $GITHUB_OUTPUT
-        else
-          echo "updated=true" >> $GITHUB_OUTPUT
-        fi
-    
-    - name: Create Pull Request
-      if: steps.check-updates.outputs.updated == 'true'
-      uses: peter-evans/create-pull-request@v7
-      with:
-        token: ${{ secrets.GITHUB_TOKEN }}
-        commit-message: "chore: update flake.lock"
-        title: "chore: update flake.lock"
-        body: |
-          Automated update of flake.lock dependencies.
-          
-          This PR was automatically created by the update-flake workflow.
-        branch: update-flake-lock
-        delete-branch: true
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 93959d1c..a5e9850d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,98 +1,13 @@
-#= Rust
-*result
-.claude/
-target/
-**/*.rs.bk
-*.pdb
-
-# IDE
-.idea/
-.vscode/
-*.swp
-*.swo
-*~
-.DS_Store
-
-# Environment
-.env
-.env.local
-.env.*.local
-
-# Logs
-*.log
-logs/
-
-# Testing
-tarpaulin-report.html
-cobertura.xml
-
-# Generated protobuf files
-crates/gate-proto/src/pb/
-
-# Benchmarking
 /target/
-/benches/target/
+/src-tauri/gen/
+/result
+/result-*
+/.direnv/
 
-# Documentation
-/target/doc/
-
-# Temporary files
-*.tmp
-*.temp
-
-# OS
-.DS_Store
-Thumbs.db
-
-# Python (for any scripts)
-__pycache__/
-*.py[cod]
-*$py.class
-.Python
-venv/
-ENV/
-
-# Node (for any tooling)
-node_modules/
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-# Credentials (extra safety)
-*.pem
-*.key
-*.cert
-*.crt
-
-# Database files
+.env
+.env.*
 *.db
 *.db-shm
 *.db-wal
-
-# Frontend build artifacts
-crates/gui/gen/
-crates/gui/resources/
-# Frontend build artifacts
-crates/frontend-daemon/dist/
-crates/frontend-daemon/assets/tailwind.output.css
-crates/frontend-tauri/dist/
-crates/frontend-tauri/assets/tailwind.output.css
-crates/frontend-relay/dist/
-crates/frontend-relay/assets/tailwind.output.css
-
-# Test files (temporary)
-crates/chat-ui/test_*.rs
-crates/chat-ui/tests/debug_*.rs
-crates/chat-ui/tests/quick_test.rs
-
-# Local development directories
-gate/
-/config/
-worktrees/
-
-# Tauri
-crates/gui/target/
-# Don't ignore icons, they're needed for the build
-# crates/gui/icons/
-gate-debug/
-.direnv/
+*.log
+.DS_Store
diff --git a/.hellas-revision b/.hellas-revision
new file mode 100644
index 00000000..63a58c5f
--- /dev/null
+++ b/.hellas-revision
@@ -0,0 +1 @@
+b4cdcd450d555f73fc8b3dd9d1af371917ff3a7c
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index d258220a..7c7c96d0 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,146 +1,18 @@
-# Contributing to Gate
-
-Thanks for your interest in improving Gate!
-
-Your contributions will be made to the project under both the Apache 2.0 and
-the MIT licenses.
-
-We accept contributions in the form of:
-
-- Pull Requests (via GitHub)
-- Bug reports (via GitHub issues)
-- User feedback (via [discord](https://discord.gg/YWZCWPrNTb))
-
-We do **not** currently accept contributions for:
-
-- Formatting (e.g., `cargo fmt`)
-- Spelling and grammar
-
-# Asking for help
-
-If you'd like help, contact us on [discord](https://discord.gg/YWZCWPrNTb).
-
-# Coding Guidelines
-
-General guidelines:
-- This is a production-grade codebase. No hacks, no shortcuts, no 'do this later'.
-- This is a greenfield project. We want the highest-quality code possible, so if we need to refactor or change things, its better to do it sooner than later.
-- Complexity is our enemy- we should strive to keep our codebase as simple as possible (but no simpler)
-- We are free to change whatever we need in this project in order to achieve our goals
-
-# Crate organisation
-## Core Crate
-This crate contains the core hellas data types, traits, etc.
-- Needs to compile across wide range of platforms, including wasm32
-- Any platform-specific dependencies (or stuff which doesn't compile for a target) MUST be feature-gated and disabled by default
-- Feature-specific code (e.g tlsforward functionality) should NOT be added to this crate
-- If at any point we find ourselves adding complexity, consider what we could refactor to make it better
-- We should always leave codebase in a better state than we found it-
-    - If we remove the last usage of a function argument, remove it from the function signature and fix callers
-    - If we remove the last usage of a function/method- remove it
-
-# Imports
-- In general, there should never be more than two-levels of `::` nesting- e.g instead of using `std::sync::Arc<MyType..>`, add `use std::sync::Arc` and just use `Arc`.
-- If we have a large number of imports from the same crate (common when loading e.g DTO types from client library):
-    - Use wildcard imports (esp if upstream crate has a `::prelude` module):
-        ```
-        use some_client::types::*;
-        fn accept(foo: FooType, bar: BarType) -> BazType;
-        ```
-    - Or module imports (should be used sparingly- `as ` should only be used when we have similarly-named type modules, to avoid confusion):
-        ```
-        use some_client_a::types as a_types;
-        use some_client_b::types as b_types:
-        fn convert(foo: a_types::Foo) -> b_types::Foo;
-        ```
-- If we need conditional dependencies (e,g for `wasm`, whatever platform):
-    - Make a single conditional and put all the imports in it, don't make a new conditional for each import
-- Put imports at the top of the file. We should not have import in e.g functions unless strictly necessary- ask my permission for this.
-
-# Types
-- We are very big of type safety. We should be using the type system as much as possible to help us.
-- This means stuff like:
-    - Deriving the `From/Into/TryInto/TryFrom` traits instead of custom conversion functions.
-    - No "magic variables"- consts and strings etc should be defined at module level `const WHATEVER_NAME: &str = "whatever-thingy"`, if appropriate
-    - Avoid unstructured data- we should perform ser/de at our system boundaries as soon as possible
-    - Try to avoid `Option<>` as much as possible- lets think about whether we can refactor to remove ambiguity
-    - Return structured errors, not Strings
-
-# Style / Formatting
-- This repo runs *strict* formatting and clippy checks. Don't worry so much about formatting as we can run `cargo fmt` before committing
-- Clippy has lots of lints for unidiomatic code, try to add code that complies with these. e.g:
-    - don't use `format!("my var: {}", var)` when you could use `format!("my var: {var}")`
-    - no match blocks where if/else would suffice
-    - appropriate use of `default` `self` etc.
-- Try to write concise, terse code when possible. I don't mean doing everything on one line with one-character variables and semicolons- just use your common sense. 
-- When fixing clippy lints, do NOT do 'lazy fixes'; do NOT 'ignore' them, by e.g:
-    - renaming variables to start with `_my_unused_var`- we should just remove the symbol altogether.
-    - adding #[allow(whatever)] - unless there is really good reason- ask me for explicit permission to do this
-
-# Logging / Tracing
-We use the `tracing` crate throughout this repo.
-- Be very sparing with what is logged and at what level- noisy/spammy logs are worse than clean ones. If a code path is expected, it shouldn't be higher level than debug.
-- We use OLTP library to export traces from e.g http servers. We should make new spans when necessary
-- We must pass along correlation ids, trace parents etc, if present. For cross-service tracing.
-- Adding explicit `use tracing::{info, warn};` etc imports cause a lot of code churn- `macro_use` them in crate root and skip importing.
-
-# Comments
-- This is a production-grade codebase, and as such documentation is very important.
-- However, too many noisy/spamming/useless comments are bad too. They get out of date and are WORSE than useless.
-- Do NOT leave comments like this:
-    - `identity: LocalIdentity,  // Store identity in handle` - this is obvious, just don't write it
-    - `identity: self.identity.clone(),  // Use stored identity` - again
-    - Totally useless: ```
-        // Update state
-        self.state_tx.send(TlsForwardState::Connecting)?;
-      ```
-    - Confusing- why is it telling us about auth middleware?!: ```
-        /// Create the configuration routes
-        pub fn router() -> axum::Router<AppState<MinimalState>> {
-            axum::Router::new().route("/api/config", routing::get(get_config).put(update_config))
-            // Note: auth middleware is applied when converting to the final router
-        }
-        ```
-- If a comment IS necessary, put it in standard rustdoc syntax. Don't go overboard with stuff like examples, defaults
-- When refactoring code, feel free to drive-by cleanup any examples of these comments you see.
-
-# Dependencies
-- Relying too much on external libraries has various downsides- it bloats the code, may introduce security issues, forces strange api
-- However we also don't want to re-invent the wheel and write too much code ourselves, and re-implementing tricky stuff like encryption has its own security issues
-- In short, just be smart about adding dependencies. If you do need to add one:
-    - Consider if it should be added as a workspace dependency- if more than one crate needs it
-    - Should some other crate be re-exporting the dependency? For example, all our http code should be in `http` crate- probably that should re-export e.g `reqwest`
-    - Be aware of features- when adding a crate, first check the available features. Probably we want to turn off the default features and just enable the ones we want
-    - When adding a dependency to Cargo.toml, use coarse versions- e.g `thiserror = "1.0"`, `tracing = "0.2"`
-    - If we remove the last remaining usage of a dependency in a crate, make sure to remove it from dependencies
-
-# Error Handling
-- This is production code, we should not have panic!(), unimplemented!(), todo!() anywhere- always return a Result.
-    - In library code (ie, shared code that is used in different contexts):
-        - Define a crate-level error type, using `thiserror`
-        - Avoid using `.map_err` wherever possible- use the `#[from]` helper in `thiserror`
-    - In application code (ie, code invoked directly by user, `main.rs`, etc)
-        - It's fine to use `anyhow`
-        - Add context where appropriate so backtraces, error messages are useful
-- Try to avoid `map_err()` wherever possible- this means not only using `From` but `Into`- for example:
-    - If you are writing HTTP handlers, your functions may return something like `impl IntoResponse`. We should implement
-    `IntoResponse` (e,g map errors, to http status codes, format as json, give description)
-    - If you are writing Tauri commands and they expect Result<String, String>, implement `Into<String>` for our errors
-
-# Visibility
-- We should think carefully about the visibility of all the code we write. Overuse of `pub` makes the library API enormous
-and brittle, not to mention slows compiling/linking.
-- If code is strictly heirachical, we can avoid making anything `pub` other than top-level crate exports. If not, we can use
-e.g `pub(crate)`
-
-# When embarking on a task
-- Read ALL relevant information BEFORE starting to code. This includes the planning stage as well as implementation itself.
-- Do not 'wait until i need to' to read existing code, do it proactively
-- If you are at all unsure about the interface you're using, search for documentation, online if neccesary.
-- If the interface is not behaving as you expect, read the documentation and fully understand whats different to what you expected, don't just bash away
-
-# TODOs, Refactoring
-- If during the process of implementing or planning some task, you see some beneficial refactoring that could be done, but is unrelated to ask in hand:
-    - write a paragraph item to docs/REFACTOR_TODOS.md
-    - this file should be treated as append-only- do not e.g update tasks in-progress here, add completed tasks etc.
-    - dont start working on this refactor unless you are explicitly told to.
+# Contributing
+
+Prepare the sibling Hellas checkout at the revision in `.hellas-revision` as
+described in the README. Enter the pinned environment with `nix develop`, then
+run `make check` before submitting changes. The flake routes Rust build output
+to `/tmp/hellas-gate-target` unless `CARGO_TARGET_DIR` is set, and supplies the
+frontend tools directly; do not run `npm install` or create caches in this
+checkout. Commit regenerated `ui/src/generated` definitions when Rust DTOs
+change; CI rejects generated binding drift.
+
+Gate should stay a thin desktop host. Protocol types, verification, transports,
+and reusable client/provider/gateway behavior belong in the sibling `hellas`
+workspace. Platform app integration, lifecycle policy, local persistence, and
+the Tauri UI belong here.
+
+Do not add an internal HTTP control plane, a companion daemon, a second protocol
+implementation, or a package-publication step. Keep Tauri invocations in
+`ui/src/api.ts`, and keep the corresponding DTOs derived from Rust.
diff --git a/Cargo.lock b/Cargo.lock
index e5ccf799..4a66389c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,14 +4,15 @@ version = 4
 
 [[package]]
 name = "acto"
-version = "0.7.4"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a026259da4f1a13b4af60cda453c392de64c58c12d239c560923e0382f42f2b9"
+checksum = "598381761ee991bf2f1455f700380e2191fb370dc9df1ee764f348b7f089d8b6"
 dependencies = [
  "parking_lot",
  "pin-project-lite",
  "rustc_version",
- "smol_str",
+ "smol_str 0.1.24",
+ "sync_wrapper",
  "tokio",
  "tracing",
 ]
@@ -24,13 +25,47 @@ checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
 [[package]]
 name = "aead"
-version = "0.6.0-rc.2"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac8202ab55fcbf46ca829833f347a82a2a4ce0596f0304ac322c2d100030cd56"
+checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
 dependencies = [
- "bytes",
- "crypto-common 0.2.0-rc.4",
- "inout",
+ "crypto-common 0.1.6",
+ "generic-array",
+]
+
+[[package]]
+name = "aead"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1973cfbc1a2daf9cf550e74e1f088c28e7f7d8c1e1418fb6c9dc5184b7e84c99"
+dependencies = [
+ "crypto-common 0.2.2",
+ "inout 0.2.2",
+]
+
+[[package]]
+name = "aes"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
+dependencies = [
+ "cfg-if",
+ "cipher 0.4.4",
+ "cpufeatures 0.2.17",
+]
+
+[[package]]
+name = "aes-gcm"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1"
+dependencies = [
+ "aead 0.5.2",
+ "aes",
+ "cipher 0.4.4",
+ "ctr",
+ "ghash",
+ "subtle",
 ]
 
 [[package]]
@@ -49,9 +84,9 @@ dependencies = [
 
 [[package]]
 name = "aho-corasick"
-version = "1.1.3"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba"
 dependencies = [
  "memchr",
 ]
@@ -64,9 +99,9 @@ checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
 
 [[package]]
 name = "alloc-stdlib"
-version = "0.2.2"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece"
+checksum = "0e76a019e91224d279006ff972f1e984179a6e9feb050adba6ce8274aef23195"
 dependencies = [
  "alloc-no-stdlib",
 ]
@@ -79,87 +114,13 @@ checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
 
 [[package]]
 name = "android_system_properties"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+checksum = "ae221649c9976a6f6c56ae1facf410f3ddb33cc661c4b7b61020a912d4237fbc"
 dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "anstream"
-version = "0.6.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ae563653d1938f79b1ab1b5e668c87c76a9930414574a6583a7b7e11a8e6192"
-dependencies = [
- "anstyle",
- "anstyle-parse 0.2.7",
- "anstyle-query",
- "anstyle-wincon",
- "colorchoice",
- "is_terminal_polyfill",
- "utf8parse",
-]
-
-[[package]]
-name = "anstream"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
-dependencies = [
- "anstyle",
- "anstyle-parse 1.0.0",
- "anstyle-query",
- "anstyle-wincon",
- "colorchoice",
- "is_terminal_polyfill",
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle"
-version = "1.0.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
-
-[[package]]
-name = "anstyle-parse"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
-dependencies = [
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle-parse"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"
-dependencies = [
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle-query"
-version = "1.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2"
-dependencies = [
- "windows-sys 0.60.2",
-]
-
-[[package]]
-name = "anstyle-wincon"
-version = "3.0.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a"
-dependencies = [
- "anstyle",
- "once_cell_polyfill",
- "windows-sys 0.60.2",
-]
-
 [[package]]
 name = "anyhow"
 version = "1.0.104"
@@ -167,238 +128,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
 
 [[package]]
-name = "arraydeque"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d902e3d592a523def97af8f317b08ce16b7ab854c1985a0c671e6f15cebc236"
-
-[[package]]
-name = "arrayref"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
-
-[[package]]
-name = "arrayvec"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
-
-[[package]]
-name = "asn1-rs"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5493c3bedbacf7fd7382c6346bbd66687d12bbaad3a89a2d2c303ee6cf20b048"
-dependencies = [
- "asn1-rs-derive 0.5.1",
- "asn1-rs-impl",
- "displaydoc",
- "nom",
- "num-traits",
- "rusticata-macros",
- "thiserror 1.0.69",
- "time",
-]
-
-[[package]]
-name = "asn1-rs"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56624a96882bb8c26d61312ae18cb45868e5a9992ea73c58e45c3101e56a1e60"
-dependencies = [
- "asn1-rs-derive 0.6.0",
- "asn1-rs-impl",
- "displaydoc",
- "nom",
- "num-traits",
- "rusticata-macros",
- "thiserror 2.0.20",
- "time",
-]
-
-[[package]]
-name = "asn1-rs-derive"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "965c2d33e53cb6b267e148a4cb0760bc01f4904c1cd4bb4002a085bb016d1490"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.106",
- "synstructure",
-]
-
-[[package]]
-name = "asn1-rs-derive"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3109e49b1e4909e9db6515a30c633684d68cdeaa252f215214cb4fa1a5bfee2c"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.106",
- "synstructure",
-]
-
-[[package]]
-name = "asn1-rs-impl"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b18050c2cd6fe86c3a76584ef5e0baf286d038cda203eb6223df2cc413565f7"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.106",
-]
-
-[[package]]
-name = "assert-json-diff"
-version = "2.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47e4f2b81832e72834d7518d8487a0396a28cc408186a2e8854c0f98011faf12"
-dependencies = [
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "async-broadcast"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532"
-dependencies = [
- "event-listener",
- "event-listener-strategy",
- "futures-core",
- "pin-project-lite",
-]
-
-[[package]]
-name = "async-channel"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
-dependencies = [
- "concurrent-queue",
- "event-listener-strategy",
- "futures-core",
- "pin-project-lite",
-]
-
-[[package]]
-name = "async-compat"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1ba85bc55464dcbf728b56d97e119d673f4cf9062be330a9a26f3acf504a590"
-dependencies = [
- "futures-core",
- "futures-io",
- "once_cell",
- "pin-project-lite",
- "tokio",
-]
-
-[[package]]
-name = "async-compression"
-version = "0.4.30"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "977eb15ea9efd848bb8a4a1a2500347ed7f0bf794edf0dc3ddcf439f43d36b23"
-dependencies = [
- "compression-codecs",
- "compression-core",
- "futures-core",
- "pin-project-lite",
- "tokio",
-]
-
-[[package]]
-name = "async-executor"
-version = "1.13.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "497c00e0fd83a72a79a39fcbd8e3e2f055d6f6c7e025f3b3d91f4f8e76527fb8"
-dependencies = [
- "async-task",
- "concurrent-queue",
- "fastrand",
- "futures-lite",
- "pin-project-lite",
- "slab",
-]
-
-[[package]]
-name = "async-io"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19634d6336019ef220f09fd31168ce5c184b295cbf80345437cc36094ef223ca"
-dependencies = [
- "async-lock",
- "cfg-if",
- "concurrent-queue",
- "futures-io",
- "futures-lite",
- "parking",
- "polling",
- "rustix",
- "slab",
- "windows-sys 0.60.2",
-]
-
-[[package]]
-name = "async-lock"
-version = "3.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fd03604047cee9b6ce9de9f70c6cd540a0520c813cbd49bae61f33ab80ed1dc"
-dependencies = [
- "event-listener",
- "event-listener-strategy",
- "pin-project-lite",
-]
-
-[[package]]
-name = "async-process"
-version = "2.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65daa13722ad51e6ab1a1b9c01299142bc75135b337923cfa10e79bbbd669f00"
-dependencies = [
- "async-channel",
- "async-io",
- "async-lock",
- "async-signal",
- "async-task",
- "blocking",
- "cfg-if",
- "event-listener",
- "futures-lite",
- "rustix",
-]
-
-[[package]]
-name = "async-recursion"
-version = "1.1.1"
+name = "arc-swap"
+version = "1.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11"
+checksum = "c049c0be4daef0b145cb3555416b3b8ef5b7888a38aea1a3a155801fe7b0810b"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.106",
+ "rustversion",
 ]
 
 [[package]]
-name = "async-signal"
-version = "0.2.12"
+name = "arrayvec"
+version = "0.7.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f567af260ef69e1d52c2b560ce0ea230763e6fbb9214a85d768760a920e3e3c1"
+checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56"
 dependencies = [
- "async-io",
- "async-lock",
- "atomic-waker",
- "cfg-if",
- "futures-core",
- "futures-io",
- "rustix",
- "signal-hook-registry",
- "slab",
- "windows-sys 0.60.2",
+ "zeroize",
 ]
 
 [[package]]
@@ -420,15 +164,9 @@ checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
-[[package]]
-name = "async-task"
-version = "4.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
-
 [[package]]
 name = "async-trait"
 version = "0.1.92"
@@ -437,7 +175,7 @@ checksum = "82f6aeea286b8eb4dd3431a1be1b59d290ace00f5bfd8e2a159bc2a05e2c1667"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.2",
+ "syn 3.0.5",
 ]
 
 [[package]]
@@ -474,24 +212,6 @@ dependencies = [
  "system-deps",
 ]
 
-[[package]]
-name = "atoi"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f28d99ec8bfea296261ca1af174f24225171fea9664ba9003cbebee704810528"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
-name = "atomic-polyfill"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4"
-dependencies = [
- "critical-section",
-]
-
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -505,16 +225,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "16e2cdb6d5ed835199484bb92bb8b3edd526effe995c61732580439c1a67e2e9"
 dependencies = [
  "base64 0.22.1",
- "http 1.5.0",
+ "http",
  "log",
  "url",
 ]
 
 [[package]]
 name = "autocfg"
-version = "1.5.0"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
 
 [[package]]
 name = "aws-lc-rs"
@@ -523,6 +243,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b281d307588d634de920874890732659e2e7672f72b5e10e81badc1a8a83621e"
 dependencies = [
  "aws-lc-sys",
+ "untrusted 0.7.1",
  "zeroize",
 ]
 
@@ -546,17 +267,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "31b698c5f9a010f6573133b09e0de5408834d0c82f8d7475a89fc1867a71cd90"
 dependencies = [
  "axum-core",
- "axum-macros",
  "bytes",
  "form_urlencoded",
  "futures-util",
- "http 1.5.0",
+ "http",
  "http-body",
  "http-body-util",
  "hyper",
  "hyper-util",
  "itoa",
- "matchit 0.8.4",
+ "matchit",
  "memchr",
  "mime",
  "percent-encoding",
@@ -570,17 +290,18 @@ dependencies = [
  "tower",
  "tower-layer",
  "tower-service",
+ "tracing",
 ]
 
 [[package]]
 name = "axum-core"
-version = "0.5.5"
+version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59446ce19cd142f8833f856eb31f3eb097812d1479ab224f54d72428ca21ea22"
+checksum = "08c78f31d7b1291f7ee735c1c6780ccde7785daae9a9206026862dab7d8792d1"
 dependencies = [
  "bytes",
  "futures-core",
- "http 1.5.0",
+ "http",
  "http-body",
  "http-body-util",
  "mime",
@@ -588,24 +309,14 @@ dependencies = [
  "sync_wrapper",
  "tower-layer",
  "tower-service",
-]
-
-[[package]]
-name = "axum-macros"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7aa268c23bfbbd2c4363b9cd302a4f504fb2a9dfe7e3451d66f35dd392e20aca"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.106",
+ "tracing",
 ]
 
 [[package]]
 name = "backon"
-version = "1.5.2"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "592277618714fbcecda9a02ba7a8781f319d26532a88553bbacc77ba5d2b3a8d"
+checksum = "cffb0e931875b666fc4fcb20fee52e9bbd1ef836fd9e9e04ec21555f9f85f7ef"
 dependencies = [
  "fastrand",
  "gloo-timers",
@@ -613,16 +324,38 @@ dependencies = [
 ]
 
 [[package]]
-name = "base16ct"
-version = "0.3.0"
+name = "base-x"
+version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8b59d472eab27ade8d770dcb11da7201c11234bef9f82ce7aa517be028d462b"
+checksum = "4cbbc9d0964165b47557570cce6c952866c2678457aca742aafc9fb771d30270"
 
 [[package]]
-name = "base32"
-version = "0.5.1"
+name = "base16ct"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
+
+[[package]]
+name = "base16ct"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd307490d624467aa6f74b0eabb77633d1f758a7b25f12bceb0b22e08d9726f6"
+
+[[package]]
+name = "base256emoji"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e9430d9a245a77c92176e649af6e275f20839a48389859d1661e9a128d077c"
+dependencies = [
+ "const-str",
+ "match-lookup",
+]
+
+[[package]]
+name = "base45"
+version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "022dfe9eb35f19ebbcb51e0b40a5ab759f46ad60cadf7297e0bd085afb50e076"
+checksum = "240e56f4d3c453c36faacb695c535a4d5f8c7d23dac175014f32eb0a71012a03"
 
 [[package]]
 name = "base64"
@@ -650,29 +383,15 @@ checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
 
 [[package]]
 name = "base64ct"
-version = "1.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55248b47b0caf0546f7988906588779981c43bb1bc9d0c44087278f80cdb44ba"
-
-[[package]]
-name = "base64urlsafedata"
-version = "0.5.5"
+version = "1.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b08e33815c87d8cadcddb1e74ac307368a3751fbe40c961538afa21a1899f21c"
-dependencies = [
- "base64 0.21.7",
- "pastey",
- "serde",
-]
+checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
 
 [[package]]
-name = "bincode"
-version = "1.3.3"
+name = "beef"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
-dependencies = [
- "serde",
-]
+checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1"
 
 [[package]]
 name = "bit-set"
@@ -680,7 +399,7 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
 dependencies = [
- "bit-vec 0.8.0",
+ "bit-vec",
 ]
 
 [[package]]
@@ -689,15 +408,6 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
 
-[[package]]
-name = "bit-vec"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51"
-dependencies = [
- "serde",
-]
-
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -706,24 +416,25 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.9.4"
+version = "2.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2261d10cca569e4643e526d8dc2e62e433cc8aba21ab764233731f8d369bf394"
+checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
 dependencies = [
- "serde",
+ "serde_core",
 ]
 
 [[package]]
 name = "blake3"
-version = "1.8.2"
+version = "1.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3888aaa89e4b2a40fca9848e400f6a658a5a3978de7be858e209cafa8be9a4a0"
+checksum = "6d9e454fc11f76977dc803893aff6304ed33d6a26efae8696573bea74baa27ae"
 dependencies = [
- "arrayref",
  "arrayvec",
  "cc",
  "cfg-if",
  "constant_time_eq",
+ "cpufeatures 0.3.1",
+ "zeroize",
 ]
 
 [[package]]
@@ -737,73 +448,49 @@ dependencies = [
 
 [[package]]
 name = "block-buffer"
-version = "0.11.0-rc.5"
+version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9ef36a6fcdb072aa548f3da057640ec10859eb4e91ddf526ee648d50c76a949"
+checksum = "d2f6c7dbe95a6ed67ad9f18e57daf93a2f034c524b99fd2b76d18fdfeb6660aa"
 dependencies = [
  "hybrid-array",
- "zeroize",
-]
-
-[[package]]
-name = "block2"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c132eebf10f5cad5289222520a4a058514204aed6d791f1cf4fe8088b82d15f"
-dependencies = [
- "objc2 0.5.2",
 ]
 
 [[package]]
 name = "block2"
-version = "0.6.1"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "340d2f0bdb2a43c1d3cd40513185b2bd7def0aa1052f956455114bc98f82dcf2"
+checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5"
 dependencies = [
- "objc2 0.6.4",
+ "objc2",
 ]
 
 [[package]]
-name = "blocking"
-version = "1.6.2"
+name = "blst"
+version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21"
+checksum = "c20659f9bbee16cbbd2f7393e40ab6309f5a98f76a2eb57a995ec508b72387fe"
 dependencies = [
- "async-channel",
- "async-task",
- "futures-io",
- "futures-lite",
- "piper",
+ "cc",
+ "glob",
+ "threadpool",
+ "zeroize",
 ]
 
 [[package]]
 name = "borsh"
-version = "1.5.7"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad8646f98db542e39fc66e68a20b2144f6a732636df7c2354e74645faaa433ce"
+checksum = "553c5d846a6ba5150c65e3b1b8ec073bcf1abc20f9b7220de384a4443ea4e20a"
 dependencies = [
- "borsh-derive",
+ "bytes",
  "cfg_aliases",
 ]
 
-[[package]]
-name = "borsh-derive"
-version = "1.5.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdd1d3c0c2f5833f22386f252fe8ed005c7f59fdcddeef025c01b4c3b9fd9ac3"
-dependencies = [
- "once_cell",
- "proc-macro-crate 3.3.0",
- "proc-macro2",
- "quote",
- "syn 2.0.106",
-]
-
 [[package]]
 name = "brotli"
-version = "8.0.2"
+version = "8.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bd8b9603c7aa97359dbd97ecf258968c95f3adddd6db2f7e7a5bef101c84560"
+checksum = "5cc91aac060a7a1e25823bdccbfb6af1875b88f17c6daac97894eed8207166b3"
 dependencies = [
  "alloc-no-stdlib",
  "alloc-stdlib",
@@ -812,39 +499,34 @@ dependencies = [
 
 [[package]]
 name = "brotli-decompressor"
-version = "5.0.0"
+version = "5.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03"
+checksum = "3a32acac15fe1967bc3986b2a6347dffc965602354ea6f450ad07e8bfd253583"
 dependencies = [
  "alloc-no-stdlib",
  "alloc-stdlib",
 ]
 
 [[package]]
-name = "bumpalo"
-version = "3.19.0"
+name = "bs58"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
+checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4"
+dependencies = [
+ "tinyvec",
+]
 
 [[package]]
-name = "bytemuck"
-version = "1.23.2"
+name = "bumpalo"
+version = "3.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3995eaeebcdf32f91f980d360f78732ddc061097ab4e39991ae7a6ace9194677"
-dependencies = [
- "bytemuck_derive",
-]
+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
 
 [[package]]
-name = "bytemuck_derive"
-version = "1.10.1"
+name = "bytemuck"
+version = "1.25.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f154e572231cb6ba2bd1176980827e3d5dc04cc183a75dea38109fbdd672d29"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.106",
-]
+checksum = "95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797"
 
 [[package]]
 name = "byteorder"
@@ -867,7 +549,7 @@ version = "0.18.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ca26ef0159422fb77631dc9d17b102f253b876fe1586b03b803e63a309b4ee2"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.13.2",
  "cairo-sys-rs",
  "glib",
  "libc",
@@ -888,11 +570,11 @@ dependencies = [
 
 [[package]]
 name = "camino"
-version = "1.1.12"
+version = "1.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd0b03af37dad7a14518b7691d81acb0f8222604ad3d1b02f6b4bed5188c0cd5"
+checksum = "bbbad30e4b4c14a39e3cc8aed085a12a327257c316619c93581e017bc52be591"
 dependencies = [
- "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -938,49 +620,19 @@ dependencies = [
 ]
 
 [[package]]
-name = "catgrad"
-version = "0.1.1"
-source = "git+https://github.com/hellas-ai/catgrad#746f7e586528ecc5cc0cd8ecaba97d6611b9ddb5"
-dependencies = [
- "gemm",
- "half",
- "log",
- "memmap2",
- "num-traits",
- "num_cpus",
- "open-hypergraphs",
- "rayon",
- "serde",
- "serde_json",
- "test-log",
-]
-
-[[package]]
-name = "catgrad-llm"
-version = "0.1.1"
-source = "git+https://github.com/hellas-ai/catgrad#746f7e586528ecc5cc0cd8ecaba97d6611b9ddb5"
+name = "cbor4ii"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b544cf8c89359205f4f990d0e6f3828db42df85b5dac95d09157a250eb0749c4"
 dependencies = [
- "catgrad",
- "half",
- "hf-hub",
- "log",
- "memmap2",
- "minijinja",
- "minijinja-contrib",
- "open-hypergraphs",
- "rayon",
- "safetensors",
  "serde",
- "serde_json",
- "thiserror 2.0.20",
- "tokenizers",
 ]
 
 [[package]]
 name = "cc"
-version = "1.2.36"
+version = "1.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5252b3d2648e5eedbc1a6f501e3c795e07025c1e93bbf8bbdd6eef7f447a6d54"
+checksum = "a3eb0f42d6c360dc3f8a821f6bf2fdea7f72bfd36b3076eb0e6d1e9e0752fff4"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -1023,20 +675,32 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "cfg_aliases"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527"
 
 [[package]]
 name = "chacha20"
-version = "0.10.0-rc.2"
+version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9bd162f2b8af3e0639d83f28a637e4e55657b7a74508dba5a9bf4da523d5c9e9"
+checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06"
 dependencies = [
  "cfg-if",
- "cipher",
- "cpufeatures",
- "zeroize",
+ "cipher 0.5.2",
+ "cpufeatures 0.3.1",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "chacha20poly1305"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b89e1c441e926b9c82a8d023f6e1b7ae0adcfaa7d621814e4d60789bac751cb"
+dependencies = [
+ "aead 0.6.1",
+ "chacha20",
+ "cipher 0.5.2",
+ "poly1305",
 ]
 
 [[package]]
@@ -1046,93 +710,87 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327"
 dependencies = [
  "iana-time-zone",
- "js-sys",
  "num-traits",
  "serde",
- "wasm-bindgen",
  "windows-link 0.2.1",
 ]
 
 [[package]]
-name = "cipher"
-version = "0.5.0-rc.1"
+name = "ciborium"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e12a13eb01ded5d32ee9658d94f553a19e804204f2dc811df69ab4d9e0cb8c7"
+checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
 dependencies = [
- "block-buffer 0.11.0-rc.5",
- "crypto-common 0.2.0-rc.4",
- "inout",
- "zeroize",
+ "ciborium-io",
+ "ciborium-ll",
+ "serde",
 ]
 
 [[package]]
-name = "clap"
-version = "4.6.6"
+name = "ciborium-io"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "473c7e07f409a8d772161724aa8db6a765a2532a70f9667eeb7b49d3d02fbdca"
-dependencies = [
- "clap_builder",
- "clap_derive",
-]
+checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
 
 [[package]]
-name = "clap_builder"
-version = "4.6.6"
+name = "ciborium-ll"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b48fea5a88e9ae728a2dcbedbfc0e730f7d60da42e1cb049a83c9fb8b789889"
+checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
 dependencies = [
- "anstream 1.0.0",
- "anstyle",
- "clap_lex",
- "strsim",
+ "ciborium-io",
+ "half",
 ]
 
 [[package]]
-name = "clap_derive"
-version = "4.6.4"
+name = "cid"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d012d2b9d65aca7f18f4d9878a045bc17899bba951561ba5ec3c2ba1eed9a061"
+checksum = "21a304f95f84d169a6f31c4d0a30d784643aaa0bbc9c1e449a2c23e963ec4971"
 dependencies = [
- "heck 0.5.0",
- "proc-macro2",
- "quote",
- "syn 3.0.2",
+ "multibase",
+ "multihash",
+ "serde",
+ "serde_bytes",
+ "unsigned-varint",
 ]
 
 [[package]]
-name = "clap_lex"
-version = "1.0.0"
+name = "cipher"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a822ea5bc7590f9d40f1ba12c0dc3c2760f3482c6984db1573ad11031420831"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common 0.1.6",
+ "inout 0.1.4",
+]
 
 [[package]]
-name = "cloudflare"
-version = "0.14.0"
+name = "cipher"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1678b3295890df5895480a7c080430e73df2b7101f1763f62a3b32dd532f1d37"
+checksum = "e8cf2a2c93cd704877c0858356ed03480ff301ee950b43f1cbe4573b088bfa6c"
 dependencies = [
- "chrono",
- "http 1.5.0",
- "reqwest 0.12.28",
- "serde",
- "serde_json",
- "serde_urlencoded",
- "serde_with",
- "thiserror 2.0.20",
- "url",
- "urlencoding",
- "uuid",
+ "block-buffer 0.12.1",
+ "crypto-common 0.2.2",
+ "inout 0.2.2",
 ]
 
 [[package]]
 name = "cmake"
-version = "0.1.54"
+version = "0.1.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7caa3f9de89ddbe2c607f4101924c5abec803763ae9534e4f4d7d8f84aa81f0"
+checksum = "c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678"
 dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "cmov"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c9ea0ac24bc397ab3c98583a3c9ba74fa56b09a4449bbe172b9b1ddb016027a"
+
 [[package]]
 name = "cobs"
 version = "0.3.0"
@@ -1142,161 +800,231 @@ dependencies = [
  "thiserror 2.0.20",
 ]
 
-[[package]]
-name = "colorchoice"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
-
 [[package]]
 name = "combine"
-version = "4.6.7"
+version = "4.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
+checksum = "cfc320937d09e6de266b31b9afb480f197d7a861be86be7cb2ea7e5d1bfffc5e"
 dependencies = [
  "bytes",
  "memchr",
 ]
 
 [[package]]
-name = "compact_str"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb1325a1cece981e8a296ab8f0f9b63ae357bd0784a9faaf548cc7b480707a"
+name = "commonware-codec"
+version = "2026.7.0"
+source = "git+https://github.com/commonwarexyz/monorepo?rev=4c3ebe4274d908557d91b637240e8b93609fb32f#4c3ebe4274d908557d91b637240e8b93609fb32f"
 dependencies = [
- "castaway",
+ "bytes",
  "cfg-if",
- "itoa",
- "rustversion",
- "ryu",
- "serde",
- "static_assertions",
+ "commonware-codec-macros",
+ "commonware-macros",
+ "paste",
+ "rand_chacha 0.10.0",
+ "thiserror 2.0.20",
 ]
 
 [[package]]
-name = "compression-codecs"
-version = "0.4.30"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "485abf41ac0c8047c07c87c72c8fb3eb5197f6e9d7ded615dfd1a00ae00a0f64"
+name = "commonware-codec-macros"
+version = "2026.7.0"
+source = "git+https://github.com/commonwarexyz/monorepo?rev=4c3ebe4274d908557d91b637240e8b93609fb32f#4c3ebe4274d908557d91b637240e8b93609fb32f"
 dependencies = [
- "brotli",
- "compression-core",
- "flate2",
- "memchr",
- "zstd",
- "zstd-safe",
+ "proc-macro-crate 3.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
 ]
 
 [[package]]
-name = "compression-core"
-version = "0.4.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e47641d3deaf41fb1538ac1f54735925e275eaf3bf4d55c81b137fba797e5cbb"
+name = "commonware-cryptography"
+version = "2026.7.0"
+source = "git+https://github.com/commonwarexyz/monorepo?rev=4c3ebe4274d908557d91b637240e8b93609fb32f#4c3ebe4274d908557d91b637240e8b93609fb32f"
+dependencies = [
+ "ahash",
+ "anyhow",
+ "aws-lc-rs",
+ "blake3",
+ "blst",
+ "bytes",
+ "cfg-if",
+ "chacha20poly1305",
+ "commonware-codec",
+ "commonware-formatting",
+ "commonware-macros",
+ "commonware-math",
+ "commonware-parallel",
+ "commonware-utils",
+ "cpufeatures 0.3.1",
+ "crc-fast",
+ "ctutils",
+ "curve25519-dalek",
+ "ecdsa 0.17.0",
+ "fixedbitset",
+ "getrandom 0.2.17",
+ "getrandom 0.4.3",
+ "hashbrown 0.17.1",
+ "num-rational",
+ "num-traits",
+ "once_cell",
+ "p256",
+ "rand 0.10.2",
+ "rand_chacha 0.10.0",
+ "rand_core 0.10.1",
+ "sha2 0.11.0",
+ "thiserror 2.0.20",
+ "x25519-dalek",
+ "zeroize",
+]
 
 [[package]]
-name = "concurrent-queue"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
+name = "commonware-formatting"
+version = "2026.7.0"
+source = "git+https://github.com/commonwarexyz/monorepo?rev=4c3ebe4274d908557d91b637240e8b93609fb32f#4c3ebe4274d908557d91b637240e8b93609fb32f"
 dependencies = [
- "crossbeam-utils",
+ "commonware-macros",
+ "const-hex",
 ]
 
 [[package]]
-name = "config"
-version = "0.15.25"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b85f248a4de22d204ceabc6299d89d2c70fbd7f09fea53c06c852369652d8139"
+name = "commonware-macros"
+version = "2026.7.0"
+source = "git+https://github.com/commonwarexyz/monorepo?rev=4c3ebe4274d908557d91b637240e8b93609fb32f#4c3ebe4274d908557d91b637240e8b93609fb32f"
 dependencies = [
- "async-trait",
- "convert_case",
- "json5",
- "pathdiff",
- "ron",
- "rust-ini",
- "serde-untagged",
- "serde_core",
- "serde_json",
- "toml 1.1.5+spec-1.1.0",
- "winnow 1.0.4",
- "yaml-rust2",
+ "commonware-macros-impl",
+ "tokio",
 ]
 
 [[package]]
-name = "console"
-version = "0.15.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"
+name = "commonware-macros-impl"
+version = "2026.7.0"
+source = "git+https://github.com/commonwarexyz/monorepo?rev=4c3ebe4274d908557d91b637240e8b93609fb32f#4c3ebe4274d908557d91b637240e8b93609fb32f"
 dependencies = [
- "encode_unicode",
- "libc",
- "once_cell",
- "unicode-width",
- "windows-sys 0.59.0",
+ "proc-macro-crate 3.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+ "toml 1.1.6+spec-1.1.0",
 ]
 
 [[package]]
-name = "console_error_panic_hook"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
+name = "commonware-math"
+version = "2026.7.0"
+source = "git+https://github.com/commonwarexyz/monorepo?rev=4c3ebe4274d908557d91b637240e8b93609fb32f#4c3ebe4274d908557d91b637240e8b93609fb32f"
 dependencies = [
- "cfg-if",
- "wasm-bindgen",
+ "bytes",
+ "commonware-codec",
+ "commonware-macros",
+ "commonware-parallel",
+ "commonware-utils",
+ "rand_core 0.10.1",
 ]
 
 [[package]]
-name = "const-oid"
-version = "0.9.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+name = "commonware-parallel"
+version = "2026.7.0"
+source = "git+https://github.com/commonwarexyz/monorepo?rev=4c3ebe4274d908557d91b637240e8b93609fb32f#4c3ebe4274d908557d91b637240e8b93609fb32f"
+dependencies = [
+ "cfg-if",
+ "commonware-macros",
+ "dashmap",
+ "futures",
+ "rayon",
+]
 
 [[package]]
-name = "const-oid"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0dabb6555f92fb9ee4140454eb5dcd14c7960e1225c6d1a6cc361f032947713e"
+name = "commonware-utils"
+version = "2026.7.0"
+source = "git+https://github.com/commonwarexyz/monorepo?rev=4c3ebe4274d908557d91b637240e8b93609fb32f#4c3ebe4274d908557d91b637240e8b93609fb32f"
+dependencies = [
+ "ahash",
+ "bytes",
+ "cfg-if",
+ "commonware-codec",
+ "commonware-formatting",
+ "commonware-macros",
+ "futures",
+ "getrandom 0.2.17",
+ "getrandom 0.3.4",
+ "getrandom 0.4.3",
+ "hashbrown 0.17.1",
+ "num-bigint",
+ "num-integer",
+ "num-rational",
+ "num-traits",
+ "parking_lot",
+ "pin-project",
+ "rand 0.10.2",
+ "thiserror 2.0.20",
+ "tokio",
+ "tracing",
+ "zeroize",
+]
 
 [[package]]
-name = "const-random"
-version = "0.1.18"
+name = "compact_str"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359"
+checksum = "9dfdd1c2274d9aa354115b09dc9a901d6c5576818cdf70d14cae2bdb47df00ab"
 dependencies = [
- "const-random-macro",
+ "castaway",
+ "cfg-if",
+ "itoa",
+ "rustversion",
+ "ryu",
+ "serde",
+ "static_assertions",
 ]
 
 [[package]]
-name = "const-random-macro"
-version = "0.1.16"
+name = "const-hex"
+version = "1.19.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e"
+checksum = "188c2337969e01e04cca32b92011b72db2b43a8b7fc2ae60741db78f7873724e"
 dependencies = [
- "getrandom 0.2.16",
- "once_cell",
- "tiny-keccak",
+ "cfg-if",
+ "cpufeatures 0.2.17",
+ "proptest",
+ "serde_core",
 ]
 
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "const-oid"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c"
+
+[[package]]
+name = "const-str"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f421161cb492475f1661ddc9815a745a1c894592070661180fdec3d4872e9c3"
+
 [[package]]
 name = "constant_time_eq"
-version = "0.3.1"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
+checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b"
 
 [[package]]
 name = "convert_case"
-version = "0.6.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca"
+checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9"
 dependencies = [
  "unicode-segmentation",
 ]
 
 [[package]]
 name = "cookie"
-version = "0.18.1"
+version = "0.18.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ddef33a339a91ea89fb53151bd0a4689cfce27055c291dfa69945475d22c747"
+checksum = "1a373e3602691c3cdea496d2f0ee5935151e6168fe87739483c463db1b2f2f87"
 dependencies = [
  "time",
  "version_check",
@@ -1304,24 +1032,14 @@ dependencies = [
 
 [[package]]
 name = "cordyceps"
-version = "0.3.4"
+version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "688d7fbb8092b8de775ef2536f36c8c31f2bc4006ece2e8d8ad2d17d00ce0a2a"
+checksum = "5b9ab7e0ca1d179628fa0172b2b97203c7fa0cd81be2448bd446fb9559ca9261"
 dependencies = [
  "loom",
  "tracing",
 ]
 
-[[package]]
-name = "core-foundation"
-version = "0.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
-dependencies = [
- "core-foundation-sys",
- "libc",
-]
-
 [[package]]
 name = "core-foundation"
 version = "0.10.1"
@@ -1338,29 +1056,16 @@ version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
-[[package]]
-name = "core-graphics"
-version = "0.24.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa95a34622365fa5bbf40b20b75dba8dfa8c94c734aea8ac9a5ca38af14316f1"
-dependencies = [
- "bitflags 2.9.4",
- "core-foundation 0.10.1",
- "core-graphics-types",
- "foreign-types 0.5.0",
- "libc",
-]
-
 [[package]]
 name = "core-graphics"
 version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "064badf302c3194842cf2c5d61f56cc88e54a759313879cdf03abdd27d0c3b97"
 dependencies = [
- "bitflags 2.9.4",
- "core-foundation 0.10.1",
+ "bitflags 2.13.2",
+ "core-foundation",
  "core-graphics-types",
- "foreign-types 0.5.0",
+ "foreign-types",
  "libc",
 ]
 
@@ -1370,11 +1075,17 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d44a101f213f6c4cdc1853d4b78aef6db6bdfa3468798cc1d9912f4735013eb"
 dependencies = [
- "bitflags 2.9.4",
- "core-foundation 0.10.1",
+ "bitflags 2.13.2",
+ "core-foundation",
  "libc",
 ]
 
+[[package]]
+name = "cpubits"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15b85f9c39137c3a891689859392b1bd49812121d0d61c9caf00d46ed5ce06ae"
+
 [[package]]
 name = "cpufeatures"
 version = "0.2.17"
@@ -1384,26 +1095,45 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "cpufeatures"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ca28b0ae3115b884660db4118d803791fd6756b6e88f39c0f3f7859060d7566"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "crc"
-version = "3.3.0"
+version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9710d3b3739c2e349eb44fe848ad0b7c8cb1e42bd87ee49371df2f7acaf3e675"
+checksum = "5eb8a2a1cd12ab0d987a5d5e825195d372001a4094a0376319d5a0ad71c1ba0d"
 dependencies = [
  "crc-catalog",
 ]
 
 [[package]]
 name = "crc-catalog"
-version = "2.4.0"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"
+checksum = "217698eaf96b4a3f0bc4f3662aaa55bdf913cd54d7204591faa790070c6d0853"
+
+[[package]]
+name = "crc-fast"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e75b2483e97a5a7da73ac68a05b629f9c53cff58d8ed1c77866079e18b00dba5"
+dependencies = [
+ "digest 0.10.7",
+ "spin 0.10.1",
+]
 
 [[package]]
 name = "crc32fast"
-version = "1.5.0"
+version = "1.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+checksum = "01a7799fd6b852db0e61728dde9a204c423b44d689dbd432522543614b490e78"
 dependencies = [
  "cfg-if",
 ]
@@ -1416,18 +1146,18 @@ checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"
 
 [[package]]
 name = "crossbeam-channel"
-version = "0.5.15"
+version = "0.5.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+checksum = "98b0cc327b5bc766e7fda9c9260cc0fa81b43a8e240440422dff70788e3f9ef1"
 dependencies = [
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.6"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+checksum = "622f3fc73690be383c7214310406f28a90e6edeadc3cea882f9d71e495b9711a"
 dependencies = [
  "crossbeam-epoch",
  "crossbeam-utils",
@@ -1435,27 +1165,18 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
-dependencies = [
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-queue"
-version = "0.3.12"
+version = "0.9.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115"
+checksum = "dc74980687109a3b14c72fd458107bf0baa1da1a1a805e178d15501ba9b86d9d"
 dependencies = [
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.21"
+version = "0.8.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6"
 
 [[package]]
 name = "crunchy"
@@ -1464,55 +1185,52 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
 
 [[package]]
-name = "crypto-common"
-version = "0.1.6"
+name = "crypto-bigint"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76"
 dependencies = [
  "generic-array",
- "typenum",
+ "rand_core 0.6.4",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
-name = "crypto-common"
-version = "0.2.0-rc.4"
+name = "crypto-bigint"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a8235645834fbc6832939736ce2f2d08192652269e11010a6240f61b908a1c6"
+checksum = "1a52aa3fcda4e6302a9f48734f234d35d4721b96f8fe07d073f07ce9df4f0271"
 dependencies = [
+ "cpubits",
+ "ctutils",
+ "getrandom 0.4.3",
  "hybrid-array",
- "rand_core 0.9.3",
+ "num-traits",
+ "rand_core 0.10.1",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
-name = "crypto_box"
-version = "0.10.0-pre.0"
+name = "crypto-common"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bda4de3e070830cf3a27a394de135b6709aefcc54d1e16f2f029271254a6ed9"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
- "aead",
- "chacha20",
- "crypto_secretbox",
- "curve25519-dalek",
- "salsa20",
- "serdect",
- "subtle",
- "zeroize",
+ "generic-array",
+ "typenum",
 ]
 
 [[package]]
-name = "crypto_secretbox"
-version = "0.2.0-pre.0"
+name = "crypto-common"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54532aae6546084a52cef855593daf9555945719eeeda9974150e0def854873e"
+checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453"
 dependencies = [
- "aead",
- "chacha20",
- "cipher",
+ "getrandom 0.4.3",
  "hybrid-array",
- "poly1305",
- "salsa20",
- "subtle",
- "zeroize",
+ "rand_core 0.10.1",
 ]
 
 [[package]]
@@ -1535,7 +1253,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13b588ba4ac1a99f7f2964d24b3d896ddc6bf847ee3855dbd4366f058cfcd331"
 dependencies = [
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
@@ -1554,18 +1272,37 @@ version = "0.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "52560adf09603e58c9a7ee1fe1dcb95a16927b17c127f0ac02d6e768a0e25bc1"
 
+[[package]]
+name = "ctr"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835"
+dependencies = [
+ "cipher 0.4.4",
+]
+
+[[package]]
+name = "ctutils"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d5515a3834141de9eafb9717ad39eea8247b5674e6066c404e8c4b365d2a29e"
+dependencies = [
+ "cmov",
+ "subtle",
+]
+
 [[package]]
 name = "curve25519-dalek"
-version = "5.0.0-pre.1"
+version = "5.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f9200d1d13637f15a6acb71e758f64624048d85b31a5fdbfd8eca1e2687d0b7"
+checksum = "b5eed333089e2e1c1ac8c6c0398e5e2497b4c9926ca6d0365ed1e099afa5bc23"
 dependencies = [
  "cfg-if",
- "cpufeatures",
+ "cpufeatures 0.3.1",
  "curve25519-dalek-derive",
- "digest 0.11.0-rc.3",
+ "digest 0.11.3",
  "fiat-crypto",
- "rand_core 0.9.3",
+ "rand_core 0.10.1",
  "rustc_version",
  "serde",
  "subtle",
@@ -1580,7 +1317,7 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
@@ -1595,12 +1332,12 @@ dependencies = [
 
 [[package]]
 name = "darling"
-version = "0.21.3"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cdf337090841a411e2a7f3deb9187445851f91b309c0c0a29e05f74a00a48c0"
+checksum = "ed17f5901b6630b993ca003def43f2f8ef4014fc13b047b57aad617ff32bc2ec"
 dependencies = [
- "darling_core 0.21.3",
- "darling_macro 0.21.3",
+ "darling_core 0.24.1",
+ "darling_macro 0.24.1",
 ]
 
 [[package]]
@@ -1614,21 +1351,20 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strsim",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
 name = "darling_core"
-version = "0.21.3"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1247195ecd7e3c85f83c8d2a366e4210d588e802133e1e355180a9870b517ea4"
+checksum = "6837e2cf7485aaae18f86181d2f0e9a7ed297a025e220aeabf63fdebd3a2ddff"
 dependencies = [
- "fnv",
  "ident_case",
  "proc-macro2",
  "quote",
  "strsim",
- "syn 2.0.106",
+ "syn 3.0.5",
 ]
 
 [[package]]
@@ -1639,25 +1375,25 @@ checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
 dependencies = [
  "darling_core 0.20.11",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
 name = "darling_macro"
-version = "0.21.3"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81"
+checksum = "2ac7135c3ef02b2f7833bbeb1be5ba7f966dcde8a87c6b87f65a778d71a02785"
 dependencies = [
- "darling_core 0.21.3",
+ "darling_core 0.24.1",
  "quote",
- "syn 2.0.106",
+ "syn 3.0.5",
 ]
 
 [[package]]
 name = "dary_heap"
-version = "0.3.7"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04d2cd9c18b9f454ed67da600630b021a8a80bf33f8c95896ab33aaf1c26b728"
+checksum = "8b1e3a325bc115f096c8b77bbf027a7c2592230e70be2d985be950d3d5e60ebe"
 dependencies = [
  "serde",
 ]
@@ -1678,113 +1414,113 @@ dependencies = [
 
 [[package]]
 name = "data-encoding"
-version = "2.9.0"
+version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a2330da5de22e8a3cb63252ce2abb30116bf5265e89c0e01bc17015ce30a476"
+checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06"
 
 [[package]]
-name = "dbus"
-version = "0.9.11"
+name = "data-encoding-macro"
+version = "0.1.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b942602992bb7acfd1f51c49811c58a610ef9181b6e66f3e519d79b540a3bf73"
+checksum = "c6a127ecbb3c4632e1525380e04c0c3fcf8dcb44d32a79ea290d8a36906edcd8"
 dependencies = [
- "libc",
- "libdbus-sys",
- "windows-sys 0.61.0",
+ "data-encoding",
+ "data-encoding-macro-internal",
 ]
 
 [[package]]
-name = "deadpool"
-version = "0.12.3"
+name = "data-encoding-macro-internal"
+version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0be2b1d1d6ec8d846f05e137292d0b89133caf95ef33695424c09568bdd39b1b"
+checksum = "c54e03a951783e8b327515db3f2a2fd0e3bed362a96b066f341ce66ed49b4ead"
 dependencies = [
- "deadpool-runtime 0.1.4",
- "lazy_static",
- "num_cpus",
- "tokio",
+ "data-encoding",
+ "syn 3.0.5",
 ]
 
 [[package]]
-name = "deadpool"
-version = "0.13.1"
+name = "dbus"
+version = "0.9.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e98a7e119cd347f4201e1159b19831029e203e2d8b790547708e8157b4acf1e"
+checksum = "3ab69f03cc8c4340c9c8e315114e1658e6775a9b16a04357973aa21cec22b32e"
 dependencies = [
- "deadpool-runtime 0.3.1",
- "tokio",
+ "libc",
+ "libdbus-sys",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "deadpool-runtime"
-version = "0.1.4"
+name = "defmt"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "092966b41edc516079bdf31ec78a2e0588d1d0c08f78b91d8307215928642b2b"
+checksum = "e2953bfe4f93bbd20cc71198842756f77d161884c99ebbabc41d80231ded88d1"
+dependencies = [
+ "bitflags 1.3.2",
+ "defmt-macros",
+]
 
 [[package]]
-name = "deadpool-runtime"
-version = "0.3.1"
+name = "defmt-macros"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2657f61fb1dd8bf37a8d51093cc7cee4e77125b22f7753f49b289f831bec2bae"
+checksum = "bad9c72e7ca2137e0dc3813245a0d282fd6daad32fd800af018306a9169b5fe8"
+dependencies = [
+ "defmt-parser",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
 
 [[package]]
-name = "der"
-version = "0.7.10"
+name = "defmt-parser"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
+checksum = "10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e"
 dependencies = [
- "const-oid 0.9.6",
- "pem-rfc7468 0.7.0",
- "zeroize",
+ "thiserror 2.0.20",
 ]
 
 [[package]]
 name = "der"
-version = "0.8.0-rc.9"
+version = "0.7.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9d8dd2f26c86b27a2a8ea2767ec7f9df7a89516e4794e54ac01ee618dda3aa4"
+checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
 dependencies = [
- "const-oid 0.10.1",
- "pem-rfc7468 1.0.0-rc.3",
+ "const-oid 0.9.6",
+ "der_derive",
+ "flagset",
  "zeroize",
 ]
 
 [[package]]
-name = "der-parser"
-version = "9.0.0"
+name = "der"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cd0a5c643689626bec213c4d8bd4d96acc8ffdb4ad4bb6bc16abf27d5f4b553"
+checksum = "a878c850e9e421b20262e9b41f9c860e4785fa07541c266b62ff9d1ef998a80a"
 dependencies = [
- "asn1-rs 0.6.2",
- "displaydoc",
- "nom",
- "num-bigint",
- "num-traits",
- "rusticata-macros",
+ "const-oid 0.10.2",
+ "pem-rfc7468",
+ "zeroize",
 ]
 
 [[package]]
-name = "der-parser"
-version = "10.0.0"
+name = "der_derive"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07da5016415d5a3c4dd39b11ed26f915f52fc4e0dc197d87908bc916e51bc1a6"
+checksum = "8034092389675178f570469e6c3b0465d3d30b4505c294a6550db47f3c17ad18"
 dependencies = [
- "asn1-rs 0.7.1",
- "displaydoc",
- "nom",
- "num-bigint",
- "num-traits",
- "rusticata-macros",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
 ]
 
 [[package]]
 name = "deranged"
-version = "0.5.3"
+version = "0.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d630bccd429a5bb5a64b5e94f693bfc48c9f8566418fda4c494cc94f911f87cc"
+checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
 dependencies = [
- "powerfmt",
- "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -1805,7 +1541,7 @@ dependencies = [
  "darling 0.20.11",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
@@ -1815,27 +1551,29 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c"
 dependencies = [
  "derive_builder_core",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
 name = "derive_more"
-version = "2.0.1"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678"
+checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
 dependencies = [
  "derive_more-impl",
 ]
 
 [[package]]
 name = "derive_more-impl"
-version = "2.0.1"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
+checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
 dependencies = [
+ "convert_case",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "rustc_version",
+ "syn 2.0.119",
  "unicode-xid",
 ]
 
@@ -1859,22 +1597,14 @@ dependencies = [
 
 [[package]]
 name = "digest"
-version = "0.11.0-rc.3"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dac89f8a64533a9b0eaa73a68e424db0fb1fd6271c74cc0125336a05f090568d"
+checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
 dependencies = [
- "block-buffer 0.11.0-rc.5",
- "const-oid 0.10.1",
- "crypto-common 0.2.0-rc.4",
-]
-
-[[package]]
-name = "directories"
-version = "6.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16f5094c54661b38d03bd7e50df373292118db60b585c08a411c6d840017fe7d"
-dependencies = [
- "dirs-sys",
+ "block-buffer 0.12.1",
+ "const-oid 0.10.2",
+ "crypto-common 0.2.2",
+ "ctutils",
 ]
 
 [[package]]
@@ -1895,48 +1625,37 @@ dependencies = [
  "libc",
  "option-ext",
  "redox_users",
- "windows-sys 0.61.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "dispatch2"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89a09f22a6c6069a18470eb92d2298acf25463f14256d24778e1230d789a2aec"
+checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38"
 dependencies = [
- "bitflags 2.9.4",
- "block2 0.6.1",
+ "bitflags 2.13.2",
+ "block2",
  "libc",
- "objc2 0.6.4",
+ "objc2",
 ]
 
 [[package]]
 name = "displaydoc"
-version = "0.2.5"
+version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
-]
-
-[[package]]
-name = "dlopen2"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09b4f5f101177ff01b8ec4ecc81eead416a8aa42819a2869311b3420fa114ffa"
-dependencies = [
- "libc",
- "once_cell",
- "winapi",
+ "syn 3.0.5",
 ]
 
 [[package]]
 name = "dlopen2"
-version = "0.8.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b54f373ccf864bf587a89e880fb7610f8d73f3045f13580948ccbcaff26febff"
+checksum = "5e2c5bd4158e66d1e215c49b837e11d62f3267b30c92f1d171c4d3105e3dc4d4"
 dependencies = [
  "dlopen2_derive",
  "libc",
@@ -1946,29 +1665,20 @@ dependencies = [
 
 [[package]]
 name = "dlopen2_derive"
-version = "0.4.1"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "788160fb30de9cdd857af31c6a2675904b16ece8fc2737b2c7127ba368c9d0f4"
+checksum = "0fbbb781877580993a8707ec48672673ec7b81eeba04cfd2310bd28c08e47c8f"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
-]
-
-[[package]]
-name = "dlv-list"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "442039f5147480ba31067cb00ada1adae6892028e40e45fc5de7b7df6dcc1b5f"
-dependencies = [
- "const-random",
+ "syn 2.0.119",
 ]
 
 [[package]]
 name = "document-features"
-version = "0.2.11"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95249b50c6c185bee49034bcb378a49dc2b5dff0be90ff6616d31d64febab05d"
+checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61"
 dependencies = [
  "litrs",
 ]
@@ -1988,18 +1698,6 @@ dependencies = [
  "tendril",
 ]
 
-[[package]]
-name = "dotenvy"
-version = "0.15.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b"
-
-[[package]]
-name = "downcast"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1435fa1053d8b2fbbe9be7e97eca7f33d37b28409959813daefc1446a14247f1"
-
 [[package]]
 name = "dpi"
 version = "0.1.2"
@@ -2011,9 +1709,9 @@ dependencies = [
 
 [[package]]
 name = "dtoa"
-version = "1.0.10"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6add3b8cff394282be81f3fc1a0605db594ed69890078ca6e2cab1c408bcf04"
+checksum = "4c3cf4824e2d5f025c7b531afcb2325364084a16806f6d47fbc1f5fbd9960590"
 
 [[package]]
 name = "dtoa-short"
@@ -2052,155 +1750,147 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
 
 [[package]]
-name = "dyn-stack"
-version = "0.13.0"
+name = "ecdsa"
+version = "0.16.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "490bd48eb68fffcfed519b4edbfd82c69cbe741d175b84f0e0cbe8c57cbe0bdd"
+checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca"
 dependencies = [
- "bytemuck",
+ "der 0.7.10",
+ "digest 0.10.7",
+ "elliptic-curve 0.13.8",
+ "rfc6979 0.4.0",
+ "signature 2.2.0",
+ "spki 0.7.3",
+]
+
+[[package]]
+name = "ecdsa"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0681a4fc24c767085329728d8dfba959af91228aa4610cca4f8ce317ba46ae0"
+dependencies = [
+ "der 0.8.2",
+ "digest 0.11.3",
+ "elliptic-curve 0.14.1",
+ "rfc6979 0.6.0",
+ "signature 3.0.0",
+ "spki 0.8.0",
+ "zeroize",
 ]
 
 [[package]]
 name = "ed25519"
-version = "3.0.0-rc.1"
+version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ef49c0b20c0ad088893ad2a790a29c06a012b3f05bcfc66661fd22a94b32129"
+checksum = "29fcf32e6c73d1079f83ab4d782de2d81620346a5f38c6237a86a22f8368980a"
 dependencies = [
- "pkcs8 0.11.0-rc.7",
- "serde",
- "signature 3.0.0-rc.4",
+ "pkcs8 0.11.0",
+ "serdect",
+ "signature 3.0.0",
 ]
 
 [[package]]
 name = "ed25519-dalek"
-version = "3.0.0-pre.1"
+version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad207ed88a133091f83224265eac21109930db09bedcad05d5252f2af2de20a1"
+checksum = "6ebaa1a2bf1290ab3bfe5a7b771d050ebffab2711c19a81691c683a5144a25de"
 dependencies = [
  "curve25519-dalek",
  "ed25519",
- "rand_core 0.9.3",
+ "rand_core 0.10.1",
  "serde",
- "sha2 0.11.0-rc.2",
- "signature 3.0.0-rc.4",
+ "sha2 0.11.0",
+ "signature 3.0.0",
  "subtle",
  "zeroize",
 ]
 
 [[package]]
 name = "either"
-version = "1.15.0"
+version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
-dependencies = [
- "serde",
-]
+checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34"
 
 [[package]]
-name = "embed-resource"
-version = "3.0.5"
+name = "elliptic-curve"
+version = "0.13.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c6d81016d6c977deefb2ef8d8290da019e27cc26167e102185da528e6c0ab38"
+checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47"
 dependencies = [
- "cc",
- "memchr",
- "rustc_version",
- "toml 0.9.12+spec-1.1.0",
- "vswhom",
- "winreg 0.55.0",
+ "base16ct 0.2.0",
+ "crypto-bigint 0.5.5",
+ "digest 0.10.7",
+ "ff 0.13.1",
+ "generic-array",
+ "group 0.13.0",
+ "pkcs8 0.10.2",
+ "rand_core 0.6.4",
+ "sec1 0.7.3",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
-name = "embed_plist"
-version = "1.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ef6b89e5b37196644d8796de5268852ff179b44e96276cf4290264843743bb7"
-
-[[package]]
-name = "embedded-io"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced"
-
-[[package]]
-name = "embedded-io"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
-
-[[package]]
-name = "encode_unicode"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
-
-[[package]]
-name = "encoding_rs"
-version = "0.8.35"
+name = "elliptic-curve"
+version = "0.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+checksum = "9d65aa39b3a5c1c9c1b745c9a019234bb7a21b77abcb4f4d266d706e2d577d65"
 dependencies = [
- "cfg-if",
+ "base16ct 1.0.0",
+ "crypto-bigint 0.7.5",
+ "crypto-common 0.2.2",
+ "digest 0.11.3",
+ "ff 0.14.0",
+ "group 0.14.0",
+ "hybrid-array",
+ "pkcs8 0.11.0",
+ "rand_core 0.10.1",
+ "sec1 0.8.1",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
-name = "endi"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3d8a32ae18130a3c84dd492d4215c3d913c3b07c6b63c2eb3eb7ff1101ab7bf"
-
-[[package]]
-name = "enum-as-inner"
-version = "0.6.1"
+name = "embed-resource"
+version = "3.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1e6a265c649f3f5979b601d26f1d05ada116434c87741c9493cb56218f76cbc"
+checksum = "fbfdaacccebec3b28e4866b8973543c7647797db5ada1bdab552e48fe665fbbd"
 dependencies = [
- "heck 0.5.0",
- "proc-macro2",
- "quote",
- "syn 2.0.106",
+ "cc",
+ "memchr",
+ "rustc_version",
+ "toml 1.1.6+spec-1.1.0",
+ "vswhom",
+ "winreg",
 ]
 
 [[package]]
-name = "enumflags2"
-version = "0.7.12"
+name = "embed_plist"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef"
-dependencies = [
- "enumflags2_derive",
- "serde",
-]
+checksum = "4ef6b89e5b37196644d8796de5268852ff179b44e96276cf4290264843743bb7"
 
 [[package]]
-name = "enumflags2_derive"
-version = "0.7.12"
+name = "embedded-io"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.106",
-]
+checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced"
 
 [[package]]
-name = "env_filter"
-version = "0.1.3"
+name = "embedded-io"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "186e05a59d4c50738528153b83b0b0194d3a29507dfec16eccd4b342903397d0"
-dependencies = [
- "log",
-]
+checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
 
 [[package]]
-name = "env_logger"
-version = "0.11.8"
+name = "enum-assoc"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13c863f0904021b108aa8b2f55046443e6b1ebde8fd4a15c399893aae4fa069f"
+checksum = "0590c4a94da3372e83493b956755a6e2266830b6e4e3b101afe66e3f39477b91"
 dependencies = [
- "anstream 0.6.20",
- "anstyle",
- "env_filter",
- "log",
+ "proc-macro2",
+ "quote",
+ "syn 3.0.5",
 ]
 
 [[package]]
@@ -2211,11 +1901,12 @@ checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "erased-serde"
-version = "0.4.6"
+version = "0.4.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e004d887f51fcb9fef17317a2f3525c887d8aa3f4f50fed920816a688284a5b7"
+checksum = "d2add8a07dd6a8d93ff627029c51de145e12686fbc36ecb298ac22e74cf02dec"
 dependencies = [
  "serde",
+ "serde_core",
  "typeid",
 ]
 
@@ -2226,7 +1917,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -2234,55 +1925,40 @@ name = "esaxx-rs"
 version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d817e038c30374a4bcb22f94d0a8a0e216958d4c3dcde369b1439fec4bdda6e6"
-dependencies = [
- "cc",
-]
 
 [[package]]
-name = "etcetera"
-version = "0.8.0"
+name = "fastrand"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "136d1b5283a1ab77bd9257427ffd09d8667ced0570b6f938942bc7568ed5b943"
-dependencies = [
- "cfg-if",
- "home",
- "windows-sys 0.48.0",
-]
+checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
 
 [[package]]
-name = "event-listener"
-version = "5.4.1"
+name = "fdeflate"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
+checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
 dependencies = [
- "concurrent-queue",
- "parking",
- "pin-project-lite",
+ "simd-adler32",
 ]
 
 [[package]]
-name = "event-listener-strategy"
-version = "0.5.4"
+name = "ff"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
+checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393"
 dependencies = [
- "event-listener",
- "pin-project-lite",
+ "rand_core 0.6.4",
+ "subtle",
 ]
 
 [[package]]
-name = "fastrand"
-version = "2.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
-
-[[package]]
-name = "fdeflate"
-version = "0.3.7"
+name = "ff"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
+checksum = "a1f686ab92a9fb0eaf188f6c6c87b89490baa6fdb0db4544ba4dc47f7942489f"
 dependencies = [
- "simd-adler32",
+ "rand_core 0.10.1",
+ "subtle",
 ]
 
 [[package]]
@@ -2303,29 +1979,42 @@ dependencies = [
 
 [[package]]
 name = "find-msvc-tools"
-version = "0.1.1"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e0f1c7c3a72c66fd80abe965175f7523475c0489a87d3ff9d6e8c87d87a9d2d"
+
+[[package]]
+name = "fixedbitset"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
+
+[[package]]
+name = "flagset"
+version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fd99930f64d146689264c637b5af2f0233a933bef0d8570e2526bf9e083192d"
+checksum = "b7ac824320a75a52197e8f2d787f6a38b6718bb6897a35142d749af3c0e8f4fe"
 
 [[package]]
 name = "flate2"
-version = "1.1.2"
+version = "1.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a3d7db9596fecd151c5f638c0ee5d5bd487b6e0ea232e5dc96d5250f6f94b1d"
+checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb"
 dependencies = [
  "crc32fast",
- "miniz_oxide",
+ "miniz_oxide 0.9.1",
+ "zlib-rs",
 ]
 
 [[package]]
 name = "flume"
-version = "0.11.1"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da0e4dd2a88388a1f4ccc7c9ce104604dab68d9f408dc34cd45823d5a9069095"
+checksum = "5e139bc46ca777eb5efaf62df0ab8cc5fd400866427e56c68b22e414e53bd3be"
 dependencies = [
  "futures-core",
  "futures-sink",
- "spin 0.9.8",
+ "spin 0.9.9",
 ]
 
 [[package]]
@@ -2346,15 +2035,6 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
 
-[[package]]
-name = "foreign-types"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
-dependencies = [
- "foreign-types-shared 0.1.1",
-]
-
 [[package]]
 name = "foreign-types"
 version = "0.5.0"
@@ -2362,26 +2042,20 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965"
 dependencies = [
  "foreign-types-macros",
- "foreign-types-shared 0.3.1",
+ "foreign-types-shared",
 ]
 
 [[package]]
 name = "foreign-types-macros"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742"
+checksum = "ea5190182e6915eb873ddbc16e23b711b6eb1f9c00a0d0a3a91b5f6228475225"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 3.0.5",
 ]
 
-[[package]]
-name = "foreign-types-shared"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
-
 [[package]]
 name = "foreign-types-shared"
 version = "0.3.1"
@@ -2397,12 +2071,6 @@ dependencies = [
  "percent-encoding",
 ]
 
-[[package]]
-name = "fragile"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28dd6caf6059519a65843af8fe2a3ae298b14b80179855aeb4adc2c1934ee619"
-
 [[package]]
 name = "fs_extra"
 version = "1.3.0"
@@ -2426,15 +2094,15 @@ dependencies = [
 
 [[package]]
 name = "futures-buffered"
-version = "0.2.12"
+version = "0.2.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8e0e1f38ec07ba4abbde21eed377082f17ccb988be9d988a5adbf4bafc118fd"
+checksum = "4421cb78ee172b6b06080093479d3c50f058e7c81b7d577bbb8d118d551d4cd5"
 dependencies = [
  "cordyceps",
  "diatomic-waker",
  "futures-core",
  "pin-project-lite",
- "spin 0.10.0",
+ "spin 0.10.1",
 ]
 
 [[package]]
@@ -2464,17 +2132,6 @@ dependencies = [
  "futures-util",
 ]
 
-[[package]]
-name = "futures-intrusive"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d930c203dd0b6ff06e0201a4a2fe9149b43c684fd4420555b26d21b1a02956f"
-dependencies = [
- "futures-core",
- "lock_api",
- "parking_lot",
-]
-
 [[package]]
 name = "futures-io"
 version = "0.3.34"
@@ -2502,7 +2159,7 @@ checksum = "9fb9654ba8355388abeb8dcb4fc62f511300867002afc858860463bdd9fe0c44"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.2",
+ "syn 3.0.5",
 ]
 
 [[package]]
@@ -2535,411 +2192,75 @@ dependencies = [
 ]
 
 [[package]]
-name = "gate-chat-ui"
-version = "0.1.0"
+name = "gdk"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9f245958c627ac99d8e529166f9823fb3b838d1d41fd2b297af3075093c2691"
 dependencies = [
- "anyhow",
- "base64 0.23.1",
- "console_error_panic_hook",
- "gloo-net 0.6.0",
- "gloo-timers",
- "js-sys",
- "serde",
- "serde_json",
- "tokio-test",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-bindgen-test",
- "web-sys",
- "yew",
+ "cairo-rs",
+ "gdk-pixbuf",
+ "gdk-sys",
+ "gio",
+ "glib",
+ "libc",
+ "pango",
 ]
 
 [[package]]
-name = "gate-core"
-version = "0.1.0"
+name = "gdk-pixbuf"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50e1f5f1b0bfb830d6ccc8066d18db35c487b1b2b1e8589b5dfe9f07e8defaec"
 dependencies = [
- "anyhow",
- "async-stream",
- "async-trait",
- "chrono",
- "config",
- "futures",
- "getrandom 0.4.3",
- "hex",
- "http 1.5.0",
- "js-sys",
- "mockall",
- "opentelemetry",
- "opentelemetry-otlp",
- "opentelemetry_sdk",
- "rand 0.9.5",
- "rust_decimal",
- "serde",
- "serde_json",
- "sqlx-d1",
- "thiserror 2.0.20",
- "tokio",
- "tracing",
- "tracing-opentelemetry",
- "tracing-subscriber",
- "url",
- "uuid",
- "worker",
+ "gdk-pixbuf-sys",
+ "gio",
+ "glib",
+ "libc",
+ "once_cell",
 ]
 
 [[package]]
-name = "gate-daemon"
-version = "0.1.0"
+name = "gdk-pixbuf-sys"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9839ea644ed9c97a34d129ad56d38a25e6756f99f3a88e15cd39c20629caf7"
 dependencies = [
- "anyhow",
- "async-trait",
- "axum",
- "base64 0.23.1",
- "catgrad-llm",
- "chrono",
- "clap",
- "config",
- "directories",
- "dotenvy",
- "futures",
- "gate-core",
- "gate-http",
- "gate-p2p",
- "gate-sqlx",
- "gate-tlsforward",
- "hex",
- "hyper-util",
- "iroh",
- "rand 0.9.5",
- "rcgen",
- "reqwest 0.12.28",
- "rustls",
- "serde",
- "serde_json",
- "tempfile",
- "thiserror 2.0.20",
- "tokio",
- "tokio-rustls",
- "tower",
- "tower-http 0.7.1",
- "tracing",
- "tracing-subscriber",
- "uuid",
- "webauthn-rs",
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
 ]
 
 [[package]]
-name = "gate-fixtures"
-version = "0.1.0"
+name = "gdk-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c2d13f38594ac1e66619e188c6d5a1adb98d11b2fcf7894fc416ad76aa2f3f7"
 dependencies = [
- "serde",
- "serde_json",
- "walkdir",
+ "cairo-sys-rs",
+ "gdk-pixbuf-sys",
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "pango-sys",
+ "pkg-config",
+ "system-deps",
 ]
 
 [[package]]
-name = "gate-frontend-common"
-version = "0.1.0"
+name = "gdkwayland-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "140071d506d223f7572b9f09b5e155afbd77428cd5cc7af8f2694c41d98dfe69"
 dependencies = [
- "base64 0.23.1",
- "gate-chat-ui",
- "gate-http",
- "getrandom 0.4.3",
- "gloo",
- "js-sys",
- "once_cell",
- "reqwest 0.12.28",
- "serde",
- "serde_json",
- "thiserror 2.0.20",
- "tracing",
- "tracing-subscriber",
- "tracing-web",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-bindgen-test",
- "wasm-logger",
- "web-sys",
- "yew",
- "yew-router",
-]
-
-[[package]]
-name = "gate-frontend-daemon"
-version = "0.1.0"
-dependencies = [
- "chrono",
- "gate-chat-ui",
- "gate-frontend-common",
- "getrandom 0.4.3",
- "gloo",
- "reqwest 0.12.28",
- "serde",
- "serde-wasm-bindgen",
- "serde_json",
- "tracing",
- "tracing-subscriber",
- "tracing-web",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-bindgen-test",
- "wasm-logger",
- "web-sys",
- "yew",
- "yew-router",
-]
-
-[[package]]
-name = "gate-frontend-relay"
-version = "0.1.0"
-dependencies = [
- "gate-frontend-common",
- "gloo-net 0.6.0",
- "gloo-timers",
- "serde",
- "serde_json",
- "tracing",
- "tracing-subscriber",
- "tracing-web",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-bindgen-test",
- "wasm-logger",
- "web-sys",
- "yew",
- "yew-router",
-]
-
-[[package]]
-name = "gate-frontend-tauri"
-version = "0.1.0"
-dependencies = [
- "gate-chat-ui",
- "gate-frontend-common",
- "getrandom 0.4.3",
- "gloo-events",
- "gloo-timers",
- "gloo-utils",
- "js-sys",
- "serde",
- "serde-wasm-bindgen",
- "serde_json",
- "tracing",
- "tracing-subscriber",
- "tracing-web",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-bindgen-test",
- "wasm-logger",
- "web-sys",
- "yew",
- "yew-router",
-]
-
-[[package]]
-name = "gate-gui"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "axum",
- "gate-core",
- "gate-daemon",
- "gate-http",
- "gate-p2p",
- "gate-sqlx",
- "gate-tlsforward",
- "hex",
- "rand 0.9.5",
- "rustls",
- "serde",
- "serde_json",
- "tauri",
- "tauri-build",
- "tauri-plugin-opener",
- "tokio",
- "tracing",
- "tracing-subscriber",
-]
-
-[[package]]
-name = "gate-http"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "async-trait",
- "axum",
- "base64 0.23.1",
- "bytes",
- "chrono",
- "futures",
- "gate-core",
- "getrandom 0.4.3",
- "http 1.5.0",
- "http-body-util",
- "hyper",
- "hyper-util",
- "jsonwebtoken",
- "opentelemetry",
- "rand 0.9.5",
- "reqwest 0.12.28",
- "rust_decimal",
- "serde",
- "serde_json",
- "sha2 0.10.9",
- "thiserror 2.0.20",
- "tokio",
- "tower",
- "tower-http 0.7.1",
- "tracing",
- "tracing-subscriber",
- "url",
- "uuid",
- "webauthn-rs",
- "wiremock",
-]
-
-[[package]]
-name = "gate-p2p"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "futures",
- "iroh",
- "thiserror 2.0.20",
- "tokio",
- "tracing",
-]
-
-[[package]]
-name = "gate-sqlx"
-version = "0.1.0"
-dependencies = [
- "async-trait",
- "chrono",
- "gate-core",
- "serde",
- "serde_json",
- "sqlx",
- "tokio",
- "tracing",
-]
-
-[[package]]
-name = "gate-tlsforward"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "async-trait",
- "axum",
- "bytes",
- "chrono",
- "clap",
- "cloudflare",
- "config",
- "dashmap",
- "deadpool 0.13.1",
- "directories",
- "futures",
- "gate-core",
- "gate-daemon",
- "gate-http",
- "gate-p2p",
- "gate-tlsforward",
- "hex",
- "http 1.5.0",
- "http-body-util",
- "hyper",
- "hyper-util",
- "instant-acme",
- "iroh",
- "n0-future",
- "rand 0.9.5",
- "rcgen",
- "serde",
- "serde_json",
- "tempfile",
- "thiserror 2.0.20",
- "tokio",
- "tokio-rustls",
- "tokio-test",
- "tower",
- "tracing",
- "tracing-subscriber",
- "trust-dns-resolver",
- "uuid",
- "x509-parser 0.18.1",
-]
-
-[[package]]
-name = "gdk"
-version = "0.18.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9f245958c627ac99d8e529166f9823fb3b838d1d41fd2b297af3075093c2691"
-dependencies = [
- "cairo-rs",
- "gdk-pixbuf",
- "gdk-sys",
- "gio",
- "glib",
- "libc",
- "pango",
-]
-
-[[package]]
-name = "gdk-pixbuf"
-version = "0.18.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50e1f5f1b0bfb830d6ccc8066d18db35c487b1b2b1e8589b5dfe9f07e8defaec"
-dependencies = [
- "gdk-pixbuf-sys",
- "gio",
- "glib",
- "libc",
- "once_cell",
-]
-
-[[package]]
-name = "gdk-pixbuf-sys"
-version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f9839ea644ed9c97a34d129ad56d38a25e6756f99f3a88e15cd39c20629caf7"
-dependencies = [
- "gio-sys",
- "glib-sys",
- "gobject-sys",
- "libc",
- "system-deps",
-]
-
-[[package]]
-name = "gdk-sys"
-version = "0.18.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c2d13f38594ac1e66619e188c6d5a1adb98d11b2fcf7894fc416ad76aa2f3f7"
-dependencies = [
- "cairo-sys-rs",
- "gdk-pixbuf-sys",
- "gio-sys",
- "glib-sys",
- "gobject-sys",
- "libc",
- "pango-sys",
- "pkg-config",
- "system-deps",
-]
-
-[[package]]
-name = "gdkwayland-sys"
-version = "0.18.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "140071d506d223f7572b9f09b5e155afbd77428cd5cc7af8f2694c41d98dfe69"
-dependencies = [
- "gdk-sys",
- "glib-sys",
- "gobject-sys",
- "libc",
- "pkg-config",
- "system-deps",
+ "gdk-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "pkg-config",
+ "system-deps",
 ]
 
 [[package]]
@@ -2970,153 +2291,42 @@ dependencies = [
 ]
 
 [[package]]
-name = "gemm"
-version = "0.18.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab96b703d31950f1aeddded248bc95543c9efc7ac9c4a21fda8703a83ee35451"
-dependencies = [
- "dyn-stack",
- "gemm-c32",
- "gemm-c64",
- "gemm-common",
- "gemm-f16",
- "gemm-f32",
- "gemm-f64",
- "num-complex",
- "num-traits",
- "paste",
- "raw-cpuid",
- "seq-macro",
-]
-
-[[package]]
-name = "gemm-c32"
-version = "0.18.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6db9fd9f40421d00eea9dd0770045a5603b8d684654816637732463f4073847"
-dependencies = [
- "dyn-stack",
- "gemm-common",
- "num-complex",
- "num-traits",
- "paste",
- "raw-cpuid",
- "seq-macro",
-]
-
-[[package]]
-name = "gemm-c64"
-version = "0.18.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfcad8a3d35a43758330b635d02edad980c1e143dc2f21e6fd25f9e4eada8edf"
-dependencies = [
- "dyn-stack",
- "gemm-common",
- "num-complex",
- "num-traits",
- "paste",
- "raw-cpuid",
- "seq-macro",
-]
-
-[[package]]
-name = "gemm-common"
-version = "0.18.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a352d4a69cbe938b9e2a9cb7a3a63b7e72f9349174a2752a558a8a563510d0f3"
-dependencies = [
- "bytemuck",
- "dyn-stack",
- "half",
- "libm",
- "num-complex",
- "num-traits",
- "once_cell",
- "paste",
- "pulp",
- "raw-cpuid",
- "rayon",
- "seq-macro",
- "sysctl",
-]
-
-[[package]]
-name = "gemm-f16"
-version = "0.18.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cff95ae3259432f3c3410eaa919033cd03791d81cebd18018393dc147952e109"
-dependencies = [
- "dyn-stack",
- "gemm-common",
- "gemm-f32",
- "half",
- "num-complex",
- "num-traits",
- "paste",
- "raw-cpuid",
- "rayon",
- "seq-macro",
-]
-
-[[package]]
-name = "gemm-f32"
-version = "0.18.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc8d3d4385393304f407392f754cd2dc4b315d05063f62cf09f47b58de276864"
-dependencies = [
- "dyn-stack",
- "gemm-common",
- "num-complex",
- "num-traits",
- "paste",
- "raw-cpuid",
- "seq-macro",
-]
-
-[[package]]
-name = "gemm-f64"
-version = "0.18.2"
+name = "gearhash"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35b2a4f76ce4b8b16eadc11ccf2e083252d8237c1b589558a49b0183545015bd"
-dependencies = [
- "dyn-stack",
- "gemm-common",
- "num-complex",
- "num-traits",
- "paste",
- "raw-cpuid",
- "seq-macro",
-]
+checksum = "616e8f476a586f1b078d9eece21f7a071f27997e709e2b471f5697deea53bda9"
 
 [[package]]
 name = "generator"
-version = "0.8.7"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "605183a538e3e2a9c1038635cc5c2d194e2ee8fd0d1b66b8349fad7dbacce5a2"
+checksum = "b3b854b0e584ead1a33f18b2fcad7cf7be18b3875c78816b753639aa501513ae"
 dependencies = [
  "cc",
  "cfg-if",
  "libc",
  "log",
  "rustversion",
- "windows 0.61.3",
+ "windows-link 0.2.1",
+ "windows-result 0.4.1",
 ]
 
 [[package]]
 name = "generic-array"
-version = "0.14.7"
+version = "0.14.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2"
 dependencies = [
  "typenum",
  "version_check",
+ "zeroize",
 ]
 
 [[package]]
 name = "getrandom"
-version = "0.2.16"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
 dependencies = [
  "cfg-if",
  "js-sys",
@@ -3149,9 +2359,20 @@ dependencies = [
  "js-sys",
  "libc",
  "r-efi 6.0.0",
+ "rand_core 0.10.1",
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "ghash"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1"
+dependencies = [
+ "opaque-debug",
+ "polyval",
+]
+
 [[package]]
 name = "gio"
 version = "0.18.4"
@@ -3190,7 +2411,7 @@ version = "0.18.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "233daaf6e83ae6a12a52055f568f9d7cf4671dabb78ff9560ab6da230ce00ee5"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.13.2",
  "futures-channel",
  "futures-core",
  "futures-executor",
@@ -3200,187 +2421,42 @@ dependencies = [
  "glib-macros",
  "glib-sys",
  "gobject-sys",
- "libc",
- "memchr",
- "once_cell",
- "smallvec",
- "thiserror 1.0.69",
-]
-
-[[package]]
-name = "glib-macros"
-version = "0.18.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bb0228f477c0900c880fd78c8759b95c7636dbd7842707f49e132378aa2acdc"
-dependencies = [
- "heck 0.4.1",
- "proc-macro-crate 2.0.0",
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "syn 2.0.106",
-]
-
-[[package]]
-name = "glib-sys"
-version = "0.18.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "063ce2eb6a8d0ea93d2bf8ba1957e78dbab6be1c2220dd3daca57d5a9d869898"
-dependencies = [
- "libc",
- "system-deps",
-]
-
-[[package]]
-name = "glob"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
-
-[[package]]
-name = "gloo"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d15282ece24eaf4bd338d73ef580c6714c8615155c4190c781290ee3fa0fd372"
-dependencies = [
- "gloo-console",
- "gloo-dialogs",
- "gloo-events",
- "gloo-file",
- "gloo-history",
- "gloo-net 0.5.0",
- "gloo-render",
- "gloo-storage",
- "gloo-timers",
- "gloo-utils",
- "gloo-worker",
-]
-
-[[package]]
-name = "gloo-console"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a17868f56b4a24f677b17c8cb69958385102fa879418052d60b50bc1727e261"
-dependencies = [
- "gloo-utils",
- "js-sys",
- "serde",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "gloo-dialogs"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf4748e10122b01435750ff530095b1217cf6546173459448b83913ebe7815df"
-dependencies = [
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "gloo-events"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27c26fb45f7c385ba980f5fa87ac677e363949e065a083722697ef1b2cc91e41"
-dependencies = [
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "gloo-file"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97563d71863fb2824b2e974e754a81d19c4a7ec47b09ced8a0e6656b6d54bd1f"
-dependencies = [
- "futures-channel",
- "gloo-events",
- "js-sys",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "gloo-history"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "903f432be5ba34427eac5e16048ef65604a82061fe93789f2212afc73d8617d6"
-dependencies = [
- "getrandom 0.2.16",
- "gloo-events",
- "gloo-utils",
- "serde",
- "serde-wasm-bindgen",
- "serde_urlencoded",
- "thiserror 1.0.69",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "gloo-net"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43aaa242d1239a8822c15c645f02166398da4f8b5c4bae795c1f5b44e9eee173"
-dependencies = [
- "futures-channel",
- "futures-core",
- "futures-sink",
- "gloo-utils",
- "http 0.2.12",
- "js-sys",
- "pin-project",
- "serde",
- "serde_json",
+ "libc",
+ "memchr",
+ "once_cell",
+ "smallvec",
  "thiserror 1.0.69",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
 ]
 
 [[package]]
-name = "gloo-net"
-version = "0.6.0"
+name = "glib-macros"
+version = "0.18.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06f627b1a58ca3d42b45d6104bf1e1a03799df472df00988b6ba21accc10580"
+checksum = "0bb0228f477c0900c880fd78c8759b95c7636dbd7842707f49e132378aa2acdc"
 dependencies = [
- "gloo-utils",
- "http 1.5.0",
- "js-sys",
- "serde",
- "serde_json",
- "thiserror 1.0.69",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
+ "heck 0.4.1",
+ "proc-macro-crate 2.0.2",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
 ]
 
 [[package]]
-name = "gloo-render"
-version = "0.2.0"
+name = "glib-sys"
+version = "0.18.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56008b6744713a8e8d98ac3dcb7d06543d5662358c9c805b4ce2167ad4649833"
+checksum = "063ce2eb6a8d0ea93d2bf8ba1957e78dbab6be1c2220dd3daca57d5a9d869898"
 dependencies = [
- "wasm-bindgen",
- "web-sys",
+ "libc",
+ "system-deps",
 ]
 
 [[package]]
-name = "gloo-storage"
-version = "0.3.0"
+name = "glob"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbc8031e8c92758af912f9bc08fbbadd3c6f3cfcbf6b64cdf3d6a81f0139277a"
-dependencies = [
- "gloo-utils",
- "js-sys",
- "serde",
- "serde_json",
- "thiserror 1.0.69",
- "wasm-bindgen",
- "web-sys",
-]
+checksum = "e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b"
 
 [[package]]
 name = "gloo-timers"
@@ -3395,58 +2471,36 @@ dependencies = [
 ]
 
 [[package]]
-name = "gloo-utils"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b5555354113b18c547c1d3a98fbf7fb32a9ff4f6fa112ce823a21641a0ba3aa"
-dependencies = [
- "js-sys",
- "serde",
- "serde_json",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "gloo-worker"
-version = "0.5.0"
+name = "gobject-sys"
+version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "085f262d7604911c8150162529cefab3782e91adb20202e8658f7275d2aefe5d"
+checksum = "0850127b514d1c4a4654ead6dedadb18198999985908e6ffe4436f53c785ce44"
 dependencies = [
- "bincode",
- "futures",
- "gloo-utils",
- "gloo-worker-macros",
- "js-sys",
- "pinned",
- "serde",
- "thiserror 1.0.69",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
+ "glib-sys",
+ "libc",
+ "system-deps",
 ]
 
 [[package]]
-name = "gloo-worker-macros"
-version = "0.1.0"
+name = "group"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "956caa58d4857bc9941749d55e4bd3000032d8212762586fa5705632967140e7"
+checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
 dependencies = [
- "proc-macro-crate 1.3.1",
- "proc-macro2",
- "quote",
- "syn 2.0.106",
+ "ff 0.13.1",
+ "rand_core 0.6.4",
+ "subtle",
 ]
 
 [[package]]
-name = "gobject-sys"
-version = "0.18.0"
+name = "group"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0850127b514d1c4a4654ead6dedadb18198999985908e6ffe4436f53c785ce44"
+checksum = "7fd1a1c7a5206c5b7a3f5a0d7ccd3ff85d0c8f5133d62a02680255b0004af5f4"
 dependencies = [
- "glib-sys",
- "libc",
- "system-deps",
+ "ff 0.14.0",
+ "rand_core 0.10.1",
+ "subtle",
 ]
 
 [[package]]
@@ -3498,22 +2552,22 @@ dependencies = [
  "proc-macro-error",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
 name = "h2"
-version = "0.4.14"
+version = "0.4.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "171fefbc92fe4a4de27e0698d6a5b392d6a0e333506bc49133760b3bcf948733"
+checksum = "ef8e5e5a340588f4452631496976cf8636d4a7ecf600239fdc27615d2530bc16"
 dependencies = [
  "atomic-waker",
  "bytes",
  "fnv",
  "futures-core",
  "futures-sink",
- "http 1.5.0",
- "indexmap 2.12.0",
+ "http",
+ "indexmap 2.14.2",
  "slab",
  "tokio",
  "tokio-util",
@@ -3522,23 +2576,13 @@ dependencies = [
 
 [[package]]
 name = "half"
-version = "2.6.0"
+version = "2.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "459196ed295495a68f7d7fe1d84f6c4b7ff0e21fe3017b2f283c6fac3ad803c9"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
 dependencies = [
- "bytemuck",
  "cfg-if",
  "crunchy",
- "num-traits",
-]
-
-[[package]]
-name = "hash32"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67"
-dependencies = [
- "byteorder",
+ "zerocopy",
 ]
 
 [[package]]
@@ -3559,16 +2603,14 @@ version = "0.15.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
 dependencies = [
- "allocator-api2",
- "equivalent",
  "foldhash 0.1.5",
 ]
 
 [[package]]
 name = "hashbrown"
-version = "0.16.0"
+version = "0.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5419bdc4f6a9207fbeba6d11b604d481addf78ecd10c11ad51e76c2f6482748d"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
 dependencies = [
  "allocator-api2",
  "equivalent",
@@ -3576,54 +2618,308 @@ dependencies = [
 ]
 
 [[package]]
-name = "hashlink"
-version = "0.10.0"
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7382cf6263419f2d8df38c55d7da83da5c18aef87fc7a7fc1fb1e344edfe14c1"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hellas-adaptors"
+version = "0.1.0"
 dependencies = [
- "hashbrown 0.15.5",
+ "futures-core",
+ "futures-util",
+ "hellas-rpc",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.20",
 ]
 
 [[package]]
-name = "hashlink"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "824e001ac4f3012dd16a264bec811403a67ca9deb6c102fc5049b32c4574b35f"
+name = "hellas-attestation"
+version = "0.1.0"
+dependencies = [
+ "base64 0.22.1",
+ "ciborium",
+ "hellas-rpc",
+ "p256",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "serde",
+ "serde_bytes",
+ "sha2 0.11.0",
+ "thiserror 2.0.20",
+ "x509-cert",
+]
+
+[[package]]
+name = "hellas-chain"
+version = "0.1.0"
+dependencies = [
+ "base64ct",
+ "bs58",
+ "bytes",
+ "commonware-codec",
+ "commonware-cryptography",
+ "commonware-parallel",
+ "hellas-genesis",
+ "hellas-kernel",
+ "hellas-rpc",
+ "hellas-wire",
+ "p256",
+ "rand 0.10.2",
+ "serde",
+ "serde_json",
+ "sha2 0.11.0",
+ "thiserror 2.0.20",
+ "tracing",
+ "url",
+]
+
+[[package]]
+name = "hellas-client"
+version = "0.1.0"
+dependencies = [
+ "async-stream",
+ "futures",
+ "hellas-attestation",
+ "hellas-rpc",
+ "hellas-wire",
+ "iroh",
+ "iroh-mdns-address-lookup",
+ "rand 0.10.2",
+ "thiserror 2.0.20",
+ "tokio",
+]
+
+[[package]]
+name = "hellas-executor"
+version = "0.1.0"
+dependencies = [
+ "async-trait",
+ "futures-core",
+ "futures-util",
+ "hellas-chain",
+ "hellas-kernel",
+ "hellas-rpc",
+ "hellas-wire",
+ "hellas-work",
+ "libc",
+ "prometheus-client",
+ "rand 0.10.2",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.20",
+ "tokio",
+ "tokio-stream",
+ "tracing",
+ "uuid",
+ "zeroize",
+]
+
+[[package]]
+name = "hellas-gate"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "cc",
+ "futures",
+ "hellas-attestation",
+ "hellas-rpc",
+ "hellas-sdk",
+ "hellas-wire",
+ "libc",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-build",
+ "tempfile",
+ "thiserror 2.0.20",
+ "tokio",
+ "tracing",
+ "tracing-subscriber",
+ "ts-rs",
+]
+
+[[package]]
+name = "hellas-gateway"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "async-stream",
+ "axum",
+ "futures",
+ "hellas-adaptors",
+ "hellas-client",
+ "hellas-presentation",
+ "hellas-rpc",
+ "hellas-wire",
+ "iroh",
+ "prometheus-client",
+ "rand 0.10.2",
+ "reqwest",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.20",
+ "tokio",
+ "tower",
+ "tracing",
+]
+
+[[package]]
+name = "hellas-genesis"
+version = "0.1.0"
+dependencies = [
+ "serde",
+ "thiserror 2.0.20",
+]
+
+[[package]]
+name = "hellas-kernel"
+version = "0.1.0"
+dependencies = [
+ "hellas-xet",
+ "k256",
+]
+
+[[package]]
+name = "hellas-presentation"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "hellas-rpc",
+ "tokenizers",
+]
+
+[[package]]
+name = "hellas-providers"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "async-stream",
+ "futures",
+ "hellas-adaptors",
+ "hellas-executor",
+ "hellas-rpc",
+ "reqwest",
+ "serde",
+ "serde_json",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "hellas-rpc"
+version = "0.1.0"
+dependencies = [
+ "bytes",
+ "ed25519-dalek",
+ "futures-core",
+ "futures-util",
+ "getrandom 0.2.17",
+ "hellas-kernel",
+ "hellas-wire",
+ "hellas-xet",
+ "k256",
+ "p256",
+ "prettyplease",
+ "proc-macro2",
+ "prost",
+ "prost-build",
+ "prost-types",
+ "protox",
+ "quote",
+ "serde",
+ "serde_bytes",
+ "serde_ipld_dagcbor",
+ "serde_json",
+ "smol_str 0.3.6",
+ "syn 2.0.119",
+ "thiserror 2.0.20",
+ "tracing",
+ "web-time",
+]
+
+[[package]]
+name = "hellas-sdk"
+version = "0.1.0"
 dependencies = [
- "hashbrown 0.16.0",
+ "anyhow",
+ "futures-core",
+ "hellas-attestation",
+ "hellas-client",
+ "hellas-executor",
+ "hellas-gateway",
+ "hellas-providers",
+ "hellas-rpc",
+ "hellas-wire",
+ "iroh",
+ "tempfile",
+ "tokio",
+ "tracing",
 ]
 
 [[package]]
-name = "heapless"
-version = "0.7.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f"
+name = "hellas-wire"
+version = "0.1.0"
 dependencies = [
- "atomic-polyfill",
- "hash32",
- "rustc_version",
+ "async-stream",
+ "bytes",
+ "data-encoding",
+ "futures",
+ "futures-core",
+ "hellas-xet",
+ "iroh",
+ "iroh-mdns-address-lookup",
+ "mainline",
+ "n0-future",
+ "portable-atomic",
+ "postcard",
+ "rustls",
  "serde",
- "spin 0.9.8",
- "stable_deref_trait",
+ "sha2 0.11.0",
+ "smol_str 0.3.6",
+ "thiserror 2.0.20",
+ "tokio",
+ "tokio-stream",
+ "tokio-tungstenite",
+ "tracing",
+ "web-time",
 ]
 
 [[package]]
-name = "heck"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+name = "hellas-work"
+version = "0.1.0"
+dependencies = [
+ "hellas-kernel",
+ "hellas-rpc",
+ "hellas-wire",
+ "hellas-xet",
+ "prost",
+ "thiserror 2.0.20",
+ "tracing",
+]
 
 [[package]]
-name = "heck"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+name = "hellas-xet"
+version = "0.1.0"
+dependencies = [
+ "blake3",
+ "gearhash",
+ "serde",
+]
 
 [[package]]
 name = "hermit-abi"
-version = "0.5.2"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+checksum = "e17592d60ebacc7d5e169f4663c5f84f9161cc90328abcfe8456f41e4dfcb284"
 
 [[package]]
 name = "hex"
@@ -3631,87 +2927,24 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
-[[package]]
-name = "hf-hub"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "629d8f3bbeda9d148036d6b0de0a3ab947abd08ce90626327fc3547a49d59d97"
-dependencies = [
- "dirs",
- "http 1.5.0",
- "indicatif",
- "libc",
- "log",
- "rand 0.9.5",
- "serde",
- "serde_json",
- "thiserror 2.0.20",
- "ureq",
- "windows-sys 0.60.2",
-]
-
 [[package]]
 name = "hickory-proto"
-version = "0.25.2"
+version = "0.26.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8a6fe56c0038198998a6f217ca4e7ef3a5e51f46163bd6dd60b5c71ca6c6502"
+checksum = "12b92608f679a6fa515dd1d15c1ff89443026e391200a2c840c7afcba482893d"
 dependencies = [
- "async-trait",
- "bytes",
- "cfg-if",
  "data-encoding",
- "enum-as-inner",
- "futures-channel",
- "futures-io",
- "futures-util",
- "h2",
- "http 1.5.0",
- "idna 1.1.0",
+ "idna",
  "ipnet",
+ "jni 0.22.4",
  "once_cell",
- "rand 0.9.5",
- "ring",
- "rustls",
+ "rand 0.10.2",
  "thiserror 2.0.20",
  "tinyvec",
- "tokio",
- "tokio-rustls",
  "tracing",
  "url",
 ]
 
-[[package]]
-name = "hickory-resolver"
-version = "0.25.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc62a9a99b0bfb44d2ab95a7208ac952d31060efc16241c87eaf36406fecf87a"
-dependencies = [
- "cfg-if",
- "futures-util",
- "hickory-proto",
- "ipconfig",
- "moka",
- "once_cell",
- "parking_lot",
- "rand 0.9.5",
- "resolv-conf",
- "rustls",
- "smallvec",
- "thiserror 2.0.20",
- "tokio",
- "tokio-rustls",
- "tracing",
-]
-
-[[package]]
-name = "hkdf"
-version = "0.12.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7"
-dependencies = [
- "hmac",
-]
-
 [[package]]
 name = "hmac"
 version = "0.12.1"
@@ -3722,12 +2955,12 @@ dependencies = [
 ]
 
 [[package]]
-name = "home"
-version = "0.5.11"
+name = "hmac"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589533453244b0995c858700322199b2becb13b627df2851f64a2775d024abcf"
+checksum = "6303bc9732ae41b04cb554b844a762b4115a61bfaa81e3e83050991eeb56863f"
 dependencies = [
- "windows-sys 0.59.0",
+ "digest 0.11.3",
 ]
 
 [[package]]
@@ -3740,17 +2973,6 @@ dependencies = [
  "markup5ever",
 ]
 
-[[package]]
-name = "http"
-version = "0.2.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
-dependencies = [
- "bytes",
- "fnv",
- "itoa",
-]
-
 [[package]]
 name = "http"
 version = "1.5.0"
@@ -3763,12 +2985,12 @@ dependencies = [
 
 [[package]]
 name = "http-body"
-version = "1.0.1"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
+checksum = "ca2a8f2913ee65f60facd6a5905613afaa448497a0230cc41ce022d93290bc2c"
 dependencies = [
  "bytes",
- "http 1.5.0",
+ "http",
 ]
 
 [[package]]
@@ -3779,17 +3001,11 @@ checksum = "23169fe34a5fbcdd3f3862e78fb9b6fccd5f02a6dc6f732547005d45631ce71c"
 dependencies = [
  "bytes",
  "futures-core",
- "http 1.5.0",
+ "http",
  "http-body",
  "pin-project-lite",
 ]
 
-[[package]]
-name = "http-range-header"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9171a2ea8a68358193d15dd5d70c1c10a2afc3e7e4c5bc92bc9f025cebd7359c"
-
 [[package]]
 name = "httparse"
 version = "1.10.1"
@@ -3804,10 +3020,11 @@ checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
 [[package]]
 name = "hybrid-array"
-version = "0.4.5"
+version = "0.4.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f471e0a81b2f90ffc0cb2f951ae04da57de8baa46fa99112b062a5173a5088d0"
+checksum = "27f864f10dfb56725ce5ce5472bc52252c8f93a4ab86327122cebf62c5f59a17"
 dependencies = [
+ "subtle",
  "typenum",
  "zeroize",
 ]
@@ -3823,7 +3040,7 @@ dependencies = [
  "futures-channel",
  "futures-core",
  "h2",
- "http 1.5.0",
+ "http",
  "http-body",
  "httparse",
  "httpdate",
@@ -3836,37 +3053,17 @@ dependencies = [
 
 [[package]]
 name = "hyper-rustls"
-version = "0.27.7"
+version = "0.27.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58"
+checksum = "33ca68d021ef39cf6463ab54c1d0f5daf03377b70561305bb89a8f83aab66e0f"
 dependencies = [
- "http 1.5.0",
+ "http",
  "hyper",
  "hyper-util",
  "rustls",
- "rustls-native-certs",
- "rustls-pki-types",
- "rustls-platform-verifier 0.6.1",
  "tokio",
  "tokio-rustls",
  "tower-service",
- "webpki-roots 1.0.3",
-]
-
-[[package]]
-name = "hyper-tls"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
-dependencies = [
- "bytes",
- "http-body-util",
- "hyper",
- "hyper-util",
- "native-tls",
- "tokio",
- "tokio-native-tls",
- "tower-service",
 ]
 
 [[package]]
@@ -3879,26 +3076,24 @@ dependencies = [
  "bytes",
  "futures-channel",
  "futures-util",
- "http 1.5.0",
+ "http",
  "http-body",
  "hyper",
  "ipnet",
  "libc",
  "percent-encoding",
  "pin-project-lite",
- "socket2 0.6.0",
- "system-configuration 0.7.0",
+ "socket2",
  "tokio",
  "tower-service",
  "tracing",
- "windows-registry",
 ]
 
 [[package]]
 name = "iana-time-zone"
-version = "0.1.63"
+version = "0.1.65"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
@@ -3906,7 +3101,7 @@ dependencies = [
  "js-sys",
  "log",
  "wasm-bindgen",
- "windows-core 0.61.2",
+ "windows-core 0.62.2",
 ]
 
 [[package]]
@@ -3930,12 +3125,13 @@ dependencies = [
 
 [[package]]
 name = "icu_collections"
-version = "2.0.0"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47"
+checksum = "fa68d21081c4a05d5a901a1c62add574c77048b6a1c67be3b50ce0b60d4ca513"
 dependencies = [
  "displaydoc",
  "potential_utf",
+ "utf8_iter",
  "yoke",
  "zerofrom",
  "zerovec",
@@ -3943,9 +3139,9 @@ dependencies = [
 
 [[package]]
 name = "icu_locale_core"
-version = "2.0.0"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a"
+checksum = "d56e28588da92eee5c3201a6eff33fabdd49b62269c8938d4ff050ce4d900deb"
 dependencies = [
  "displaydoc",
  "litemap",
@@ -3956,11 +3152,10 @@ dependencies = [
 
 [[package]]
 name = "icu_normalizer"
-version = "2.0.0"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979"
+checksum = "12f9cf5f235641ed274641dd81c3f28d870e276763d0797aeeab72317b1c646f"
 dependencies = [
- "displaydoc",
  "icu_collections",
  "icu_normalizer_data",
  "icu_properties",
@@ -3971,42 +3166,39 @@ dependencies = [
 
 [[package]]
 name = "icu_normalizer_data"
-version = "2.0.0"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3"
+checksum = "1563da1ed3e0b3bf3d74c9b85917ac9c56464d2f57242270c09c9e752f8021a0"
 
 [[package]]
 name = "icu_properties"
-version = "2.0.1"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b"
+checksum = "7e7ca276ad3145661a65914e6daf131ca5120cd3dcee8f8f3214b8875184a148"
 dependencies = [
  "displaydoc",
  "icu_collections",
  "icu_locale_core",
  "icu_properties_data",
  "icu_provider",
- "potential_utf",
  "zerotrie",
  "zerovec",
 ]
 
 [[package]]
 name = "icu_properties_data"
-version = "2.0.1"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632"
+checksum = "e590f038c1464a96894fd6d10127e90a8be4509f56ff7ecef851b15cee0b7caa"
 
 [[package]]
 name = "icu_provider"
-version = "2.0.0"
+version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af"
+checksum = "d27bbb9d3abbefac45d55f647c9de1d44aafcd1186eb91879afef17c396c3e73"
 dependencies = [
  "displaydoc",
  "icu_locale_core",
- "stable_deref_trait",
- "tinystr",
  "writeable",
  "yoke",
  "zerofrom",
@@ -4021,14 +3213,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
 
 [[package]]
-name = "idna"
-version = "0.4.0"
+name = "identity-hash"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d20d6b07bfbc108882d88ed8e37d39636dcc260e15e30c45e6ba089610b917c"
-dependencies = [
- "unicode-bidi",
- "unicode-normalization",
-]
+checksum = "dfdd7caa900436d8f13b2346fe10257e0c05c1f1f9e351f4f5d57c03bd5f45da"
 
 [[package]]
 name = "idna"
@@ -4043,9 +3231,9 @@ dependencies = [
 
 [[package]]
 name = "idna_adapter"
-version = "1.2.1"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714"
 dependencies = [
  "icu_normalizer",
  "icu_properties",
@@ -4053,45 +3241,24 @@ dependencies = [
 
 [[package]]
 name = "igd-next"
-version = "0.16.2"
+version = "0.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "516893339c97f6011282d5825ac94fc1c7aad5cad26bdc2d0cee068c0bf97f97"
+checksum = "de7238d487a9aff61f81b5ab41c0a841532a115a398b5fa92a2fadd0885e2581"
 dependencies = [
- "async-trait",
  "attohttpc",
  "bytes",
  "futures",
- "http 1.5.0",
+ "http",
  "http-body-util",
  "hyper",
  "hyper-util",
  "log",
- "rand 0.9.5",
+ "rand 0.10.2",
  "tokio",
  "url",
  "xmltree",
 ]
 
-[[package]]
-name = "implicit-clone"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88e4c5423e5b38b6f175b42561a08f6ddbc8ed3a3275f48eb350ba2dfe9a6b60"
-dependencies = [
- "implicit-clone-derive",
- "indexmap 2.12.0",
-]
-
-[[package]]
-name = "implicit-clone-derive"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "699c1b6d335e63d0ba5c1e1c7f647371ce989c3bcbe1f7ed2b85fa56e3bd1a21"
-dependencies = [
- "quote",
- "syn 2.0.106",
-]
-
 [[package]]
 name = "indexmap"
 version = "1.9.3"
@@ -4105,29 +3272,16 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.12.0"
+version = "2.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6717a8d2a5a929a1a2eb43a12812498ed141a0bcfb7e8f7844fbdbe4303bba9f"
+checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
 dependencies = [
  "equivalent",
- "hashbrown 0.16.0",
+ "hashbrown 0.17.1",
  "serde",
  "serde_core",
 ]
 
-[[package]]
-name = "indicatif"
-version = "0.17.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "183b3088984b400f4cfac3620d5e076c84da5364016b4f49473de574b2586235"
-dependencies = [
- "console",
- "number_prefix",
- "portable-atomic",
- "unicode-width",
- "web-time",
-]
-
 [[package]]
 name = "infer"
 version = "0.19.0"
@@ -4139,114 +3293,93 @@ dependencies = [
 
 [[package]]
 name = "inout"
-version = "0.2.1"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7357b6e7aa75618c7864ebd0634b115a7218b0615f4cb1df33ac3eca23943d4"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
 dependencies = [
- "hybrid-array",
+ "generic-array",
 ]
 
 [[package]]
-name = "instant"
-version = "0.1.13"
+name = "inout"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222"
+checksum = "4250ce6452e92010fdf7268ccc5d14faa80bb12fc741938534c58f16804e03c7"
 dependencies = [
- "cfg-if",
- "js-sys",
- "wasm-bindgen",
- "web-sys",
+ "hybrid-array",
 ]
 
 [[package]]
-name = "instant-acme"
-version = "0.8.5"
+name = "ipconfig"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f05ad37c421b962354c358d347d4a6130151df9407978372d3ad7f0c8f71a64"
+checksum = "4d40460c0ce33d6ce4b0630ad68ff63d6661961c48b6dba35e5a4d81cfb48222"
 dependencies = [
- "async-trait",
- "base64 0.22.1",
- "bytes",
- "http 1.5.0",
- "http-body",
- "http-body-util",
- "httpdate",
- "hyper",
- "hyper-rustls",
- "hyper-util",
- "rcgen",
- "ring",
- "rustls",
- "rustls-pki-types",
- "serde",
- "serde_json",
- "thiserror 2.0.20",
- "tokio",
+ "socket2",
+ "widestring",
+ "windows-registry",
+ "windows-result 0.4.1",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "ipconfig"
-version = "0.3.2"
+name = "ipld-core"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b58db92f96b720de98181bbbe63c831e87005ab460c1bf306eb2622b4707997f"
+checksum = "090f624976d72f0b0bb71b86d58dc16c15e069193067cb3a3a09d655246cbbda"
 dependencies = [
- "socket2 0.5.10",
- "widestring",
- "windows-sys 0.48.0",
- "winreg 0.50.0",
+ "cid",
+ "serde",
+ "serde_bytes",
 ]
 
 [[package]]
 name = "ipnet"
-version = "2.11.0"
+version = "2.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
+checksum = "791930b43c0d5973160d90a8f3894509f2b273430f5c5c73b668636d0287c5c0"
 
 [[package]]
 name = "iroh"
-version = "0.95.1"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2374ba3cdaac152dc6ada92d971f7328e6408286faab3b7350842b2ebbed4789"
+checksum = "b2f8d1cfffc83efe39a1031aab423ce09cb8048071baba550508931e9a81ce46"
 dependencies = [
- "aead",
  "backon",
+ "blake3",
  "bytes",
  "cfg_aliases",
- "crypto_box",
+ "ctutils",
  "data-encoding",
  "derive_more",
  "ed25519-dalek",
  "futures-util",
- "getrandom 0.3.4",
- "hickory-resolver",
- "http 1.5.0",
- "igd-next",
- "instant",
+ "getrandom 0.4.3",
+ "http",
+ "ipnet",
  "iroh-base",
+ "iroh-dns",
  "iroh-metrics",
- "iroh-quinn",
- "iroh-quinn-proto",
- "iroh-quinn-udp",
  "iroh-relay",
  "n0-error",
  "n0-future",
  "n0-watcher",
- "netdev",
  "netwatch",
+ "noq",
+ "noq-proto",
+ "noq-udp",
+ "papaya",
  "pin-project",
- "pkarr",
- "pkcs8 0.11.0-rc.7",
+ "portable-atomic",
  "portmapper",
- "rand 0.9.5",
- "reqwest 0.12.28",
+ "rand 0.10.2",
+ "reqwest",
+ "rustc-hash",
  "rustls",
  "rustls-pki-types",
- "rustls-platform-verifier 0.5.3",
- "rustls-webpki",
  "serde",
  "smallvec",
  "strum",
- "swarm-discovery",
  "time",
  "tokio",
  "tokio-stream",
@@ -4254,144 +3387,130 @@ dependencies = [
  "tracing",
  "url",
  "wasm-bindgen-futures",
- "webpki-roots 1.0.3",
- "z32",
 ]
 
 [[package]]
 name = "iroh-base"
-version = "0.95.1"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25a8c5fb1cc65589f0d7ab44269a76f615a8c4458356952c9b0ef1c93ea45ff8"
+checksum = "ffd1efd1aaecd68d4d1b0727a30c5811f43fb822843e48f65f6e5db3b7256cc9"
 dependencies = [
  "curve25519-dalek",
  "data-encoding",
+ "data-encoding-macro",
  "derive_more",
  "ed25519-dalek",
+ "getrandom 0.4.3",
  "n0-error",
- "rand_core 0.9.3",
+ "rand 0.10.2",
  "serde",
  "url",
  "zeroize",
- "zeroize_derive",
 ]
 
 [[package]]
-name = "iroh-metrics"
-version = "0.37.0"
+name = "iroh-dns"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79e3381da7c93c12d353230c74bba26131d1c8bf3a4d8af0fec041546454582e"
+checksum = "80276761b56e904e26ea71d0863beef0bb8d5ab6b639cbd1338e4b615209e3a1"
 dependencies = [
- "iroh-metrics-derive",
- "itoa",
+ "arc-swap",
+ "cfg_aliases",
+ "derive_more",
+ "iroh-base",
+ "n0-dns-resolver",
  "n0-error",
- "postcard",
- "ryu",
- "serde",
+ "n0-future",
+ "portable-atomic",
+ "rand 0.10.2",
+ "rustls",
+ "simple-dns",
+ "strum",
+ "tokio",
  "tracing",
+ "url",
 ]
 
 [[package]]
-name = "iroh-metrics-derive"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4e12bd0763fd16062f5cc5e8db15dd52d26e75a8af4c7fb57ccee3589b344b8"
-dependencies = [
- "heck 0.5.0",
- "proc-macro2",
- "quote",
- "syn 2.0.106",
-]
-
-[[package]]
-name = "iroh-quinn"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cde160ebee7aabede6ae887460cd303c8b809054224815addf1469d54a6fcf7"
-dependencies = [
- "bytes",
- "cfg_aliases",
- "iroh-quinn-proto",
- "iroh-quinn-udp",
- "pin-project-lite",
- "rustc-hash",
- "rustls",
- "socket2 0.5.10",
- "thiserror 2.0.20",
+name = "iroh-mdns-address-lookup"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c1f941695731bc3999d8c13d7e94d50e229427da81ac957eec3818264f17559"
+dependencies = [
+ "data-encoding",
+ "derive_more",
+ "futures-util",
+ "iroh",
+ "iroh-base",
+ "n0-error",
+ "n0-future",
+ "n0-watcher",
+ "swarm-discovery",
  "tokio",
+ "tokio-stream",
  "tracing",
- "web-time",
 ]
 
 [[package]]
-name = "iroh-quinn-proto"
-version = "0.13.0"
+name = "iroh-metrics"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "929d5d8fa77d5c304d3ee7cae9aede31f13908bd049f9de8c7c0094ad6f7c535"
+checksum = "291065721ad7c477b972e581bbc528df031dc8eb5e39fe1ff3300ae5dfb157ef"
 dependencies = [
- "bytes",
- "getrandom 0.2.16",
- "rand 0.8.8",
- "ring",
- "rustc-hash",
- "rustls",
- "rustls-pki-types",
- "slab",
- "thiserror 2.0.20",
- "tinyvec",
+ "iroh-metrics-derive",
+ "itoa",
+ "n0-error",
+ "portable-atomic",
+ "ryu",
+ "serde",
  "tracing",
- "web-time",
 ]
 
 [[package]]
-name = "iroh-quinn-udp"
-version = "0.5.7"
+name = "iroh-metrics-derive"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c53afaa1049f7c83ea1331f5ebb9e6ebc5fdd69c468b7a22dd598b02c9bcc973"
+checksum = "1ae5f0c4405d1fbc9fb16ff422ca40620e93dc36c30ecaba0c2aee3992b7bd48"
 dependencies = [
- "cfg_aliases",
- "libc",
- "once_cell",
- "socket2 0.5.10",
- "tracing",
- "windows-sys 0.59.0",
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
 ]
 
 [[package]]
 name = "iroh-relay"
-version = "0.95.1"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43fbdf2aeffa7d6ede1a31f6570866c2199b1cee96a0b563994623795d1bac2c"
+checksum = "beb2294a9749d6a25fd7cd8bcf0fccd932f20716d4f967d85d3f23c7135ae6a2"
 dependencies = [
  "blake3",
  "bytes",
  "cfg_aliases",
  "data-encoding",
  "derive_more",
- "getrandom 0.3.4",
- "hickory-resolver",
- "http 1.5.0",
+ "getrandom 0.4.3",
+ "http",
  "http-body-util",
  "hyper",
  "hyper-util",
  "iroh-base",
+ "iroh-dns",
  "iroh-metrics",
- "iroh-quinn",
- "iroh-quinn-proto",
- "lru 0.16.2",
+ "lru 0.18.4",
  "n0-error",
  "n0-future",
+ "noq",
+ "noq-proto",
  "num_enum",
  "pin-project",
- "pkarr",
  "postcard",
- "rand 0.9.5",
- "reqwest 0.12.28",
+ "rand 0.10.2",
+ "reqwest",
  "rustls",
  "rustls-pki-types",
  "serde",
  "serde_bytes",
- "sha1 0.11.0-rc.2",
  "strum",
  "tokio",
  "tokio-rustls",
@@ -4399,36 +3518,10 @@ dependencies = [
  "tokio-websockets",
  "tracing",
  "url",
- "webpki-roots 1.0.3",
+ "webpki-roots 1.0.9",
  "ws_stream_wasm",
- "z32",
-]
-
-[[package]]
-name = "is-docker"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "928bae27f42bc99b60d9ac7334e3a21d10ad8f1835a4e12ec3ec0464765ed1b3"
-dependencies = [
- "once_cell",
-]
-
-[[package]]
-name = "is-wsl"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "173609498df190136aa7dea1a91db051746d339e18476eed5ca40521f02d7aa5"
-dependencies = [
- "is-docker",
- "once_cell",
 ]
 
-[[package]]
-name = "is_terminal_polyfill"
-version = "1.70.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
-
 [[package]]
 name = "itertools"
 version = "0.14.0"
@@ -4440,9 +3533,9 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.15"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "javascriptcore-rs"
@@ -4467,6 +3560,60 @@ dependencies = [
  "system-deps",
 ]
 
+[[package]]
+name = "jiff"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ab1baf72f08796de0260609515130699b890ac25f30e610ad894bc5856cafdb"
+dependencies = [
+ "defmt",
+ "jiff-core",
+ "jiff-static",
+ "jiff-tzdb-platform",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde_core",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "jiff-core"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e52fe76043ccecc9005d2305ebaadf7d7fc0cc89ca6baa10a94d6bc68c7128c"
+dependencies = [
+ "defmt",
+ "log",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "378268a1116ad67ae6228701118ac9f491d78fda38a40a1f1a9e1348de6f7212"
+dependencies = [
+ "jiff-core",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "jiff-tzdb"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "142bd39932ad231f10513df9ab62661fead8719872150b7ad02a2df79f4e141e"
+
+[[package]]
+name = "jiff-tzdb-platform"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8"
+dependencies = [
+ "jiff-tzdb",
+]
+
 [[package]]
 name = "jni"
 version = "0.21.1"
@@ -4476,36 +3623,89 @@ dependencies = [
  "cesu8",
  "cfg-if",
  "combine",
- "jni-sys",
+ "jni-sys 0.3.1",
  "log",
  "thiserror 1.0.69",
  "walkdir",
  "windows-sys 0.45.0",
 ]
 
+[[package]]
+name = "jni"
+version = "0.22.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5efd9a482cf3a427f00d6b35f14332adc7902ce91efb778580e180ff90fa3498"
+dependencies = [
+ "cfg-if",
+ "combine",
+ "jni-macros",
+ "jni-sys 0.4.1",
+ "log",
+ "simd_cesu8",
+ "thiserror 2.0.20",
+ "walkdir",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "jni-macros"
+version = "0.22.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "simd_cesu8",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "jni-sys"
-version = "0.3.0"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258"
+dependencies = [
+ "jni-sys 0.4.1",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
+checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2"
+dependencies = [
+ "jni-sys-macros",
+]
+
+[[package]]
+name = "jni-sys-macros"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264"
+dependencies = [
+ "quote",
+ "syn 2.0.119",
+]
 
 [[package]]
 name = "jobserver"
-version = "0.1.34"
+version = "0.1.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
+checksum = "1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3"
 dependencies = [
- "getrandom 0.3.4",
+ "getrandom 0.4.3",
  "libc",
 ]
 
 [[package]]
 name = "js-sys"
-version = "0.3.78"
+version = "0.3.105"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c0b063578492ceec17683ef2f8c5e89121fbd0b172cbc280635ab7567db2738"
+checksum = "ce57d20d1ea864ce2ac172ab472d409214f4fd359f0b2a2775abdf522e2af99e"
 dependencies = [
- "once_cell",
+ "cfg-if",
+ "futures-util",
  "wasm-bindgen",
 ]
 
@@ -4521,17 +3721,6 @@ dependencies = [
  "thiserror 1.0.69",
 ]
 
-[[package]]
-name = "json5"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96b0db21af676c1ce64250b5f40f3ce2cf27e4e47cb91ed91eb6fe9350b430c1"
-dependencies = [
- "pest",
- "pest_derive",
- "serde",
-]
-
 [[package]]
 name = "jsonptr"
 version = "0.6.3"
@@ -4543,18 +3732,17 @@ dependencies = [
 ]
 
 [[package]]
-name = "jsonwebtoken"
-version = "9.3.1"
+name = "k256"
+version = "0.13.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a87cc7a48537badeae96744432de36f4be2b4a34a05a5ef32e9dd8a1c169dde"
+checksum = "f6e3919bbaa2945715f0bb6d3934a173d1e9a59ac23767fbaaef277265a7411b"
 dependencies = [
- "base64 0.22.1",
- "js-sys",
- "pem 3.0.5",
- "ring",
- "serde",
- "serde_json",
- "simple_asn1",
+ "cfg-if",
+ "ecdsa 0.16.9",
+ "elliptic-curve 0.13.8",
+ "once_cell",
+ "sha2 0.10.9",
+ "signature 2.2.0",
 ]
 
 [[package]]
@@ -4563,7 +3751,7 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b750dcadc39a09dbadd74e118f6dd6598df77fa01df0cfcdc52c28dece74528a"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.13.2",
  "serde",
  "unicode-segmentation",
 ]
@@ -4573,9 +3761,6 @@ name = "lazy_static"
 version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
-dependencies = [
- "spin 0.9.8",
-]
 
 [[package]]
 name = "libappindicator"
@@ -4603,9 +3788,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.182"
+version = "0.2.189"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
 
 [[package]]
 name = "libdbus-sys"
@@ -4626,40 +3811,15 @@ dependencies = [
  "winapi",
 ]
 
-[[package]]
-name = "libm"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
-
 [[package]]
 name = "libredox"
-version = "0.1.9"
+version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "391290121bad3d37fbddad76d8f5d1c1c314cfc646d143d7e07a3086ddff0ce3"
+checksum = "6480ccc157a1389bb2e4891b24751b0f798ba640d22386f23143fbcc89da195a"
 dependencies = [
- "bitflags 2.9.4",
  "libc",
- "redox_syscall",
-]
-
-[[package]]
-name = "libsqlite3-sys"
-version = "0.30.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e99fb7a497b1e3339bc746195567ed8d3e24945ecd636e3619d20b9de9e9149"
-dependencies = [
- "cc",
- "pkg-config",
- "vcpkg",
 ]
 
-[[package]]
-name = "linked-hash-map"
-version = "0.5.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
-
 [[package]]
 name = "linux-raw-sys"
 version = "0.12.1"
@@ -4668,31 +3828,96 @@ checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
 
 [[package]]
 name = "litemap"
-version = "0.8.0"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956"
+checksum = "47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae"
 
 [[package]]
 name = "litrs"
-version = "0.4.2"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5e54036fe321fd421e10d732f155734c4e4afd610dd556d9a82833ab3ee0bed"
+checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"
 
 [[package]]
 name = "lock_api"
-version = "0.4.13"
+version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96936507f153605bddfcda068dd804796c84324ed2510809e5b2a624c81da765"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
 dependencies = [
- "autocfg",
  "scopeguard",
 ]
 
 [[package]]
 name = "log"
-version = "0.4.28"
+version = "0.4.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"
+
+[[package]]
+name = "logos"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff472f899b4ec2d99161c51f60ff7075eeb3097069a36050d8037a6325eb8154"
+dependencies = [
+ "logos-derive 0.15.1",
+]
+
+[[package]]
+name = "logos"
+version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
+checksum = "eb2c55a318a87600ea870ff8c2012148b44bf18b74fad48d0f835c38c7d07c5f"
+dependencies = [
+ "logos-derive 0.16.1",
+]
+
+[[package]]
+name = "logos-codegen"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "192a3a2b90b0c05b27a0b2c43eecdb7c415e29243acc3f89cc8247a5b693045c"
+dependencies = [
+ "beef",
+ "fnv",
+ "lazy_static",
+ "proc-macro2",
+ "quote",
+ "regex-syntax",
+ "rustc_version",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "logos-codegen"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58b3ffaa284e1350d017a57d04ada118c4583cf260c8fb01e0fe28a2e9cf8970"
+dependencies = [
+ "fnv",
+ "proc-macro2",
+ "quote",
+ "regex-automata",
+ "regex-syntax",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "logos-derive"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "605d9697bcd5ef3a42d38efc51541aa3d6a4a25f7ab6d1ed0da5ac632a26b470"
+dependencies = [
+ "logos-codegen 0.15.1",
+]
+
+[[package]]
+name = "logos-derive"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52d3a9855747c17eaf4383823f135220716ab49bea5fbea7dd42cc9a92f8aa31"
+dependencies = [
+ "logos-codegen 0.16.1",
+]
 
 [[package]]
 name = "loom"
@@ -4709,50 +3934,69 @@ dependencies = [
 
 [[package]]
 name = "lru"
-version = "0.13.0"
+version = "0.16.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "227748d55f2f0ab4735d87fd623798cb6b664512fe979705f829c9f81c934465"
+checksum = "7f66e8d5d03f609abc3a39e6f08e4164ebf1447a732906d39eb9b99b7919ef39"
 
 [[package]]
 name = "lru"
-version = "0.16.2"
+version = "0.18.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96051b46fc183dc9cd4a223960ef37b9af631b55191852a8274bfef064cda20f"
+checksum = "ff9840bcc50b71349309900da0ce7279aa336ae71d73250b07998932c7d97c25"
 dependencies = [
- "hashbrown 0.16.0",
+ "hashbrown 0.17.1",
 ]
 
 [[package]]
-name = "lru-cache"
-version = "0.1.2"
+name = "lru-slab"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c"
-dependencies = [
- "linked-hash-map",
-]
+checksum = "4050469837a6ff301cd14c1f8f24f88549e6d548f24f64e2148eb0f72cebc51f"
 
 [[package]]
-name = "lru-slab"
-version = "0.1.2"
+name = "mac-addr"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
+checksum = "d3d25b0e0b648a86960ac23b7ad4abb9717601dec6f66c165f5b037f3f03065f"
 
 [[package]]
 name = "macro_rules_attribute"
-version = "0.2.2"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65049d7923698040cd0b1ddcced9b0eb14dd22c5f86ae59c3740eab64a676520"
+checksum = "b3ae8f6d608c795738406608304d30a2dfbdc8e58e44f7ba43236da5208ded3c"
 dependencies = [
  "macro_rules_attribute-proc_macro",
- "paste",
+ "pastey",
+]
+
+[[package]]
+name = "macro_rules_attribute-proc_macro"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc04a4c58212d57930a24bf47d3fa87485264a3a054e9c10e042eb373573ad3c"
+
+[[package]]
+name = "mainline"
+version = "7.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dfad9601b9117218868271c05403853593d4817e7abeab5c95e11eee16382bb"
+dependencies = [
+ "crc",
+ "document-features",
+ "dyn-clone",
+ "ed25519-dalek",
+ "flume",
+ "futures-lite",
+ "getrandom 0.4.3",
+ "lru 0.16.4",
+ "serde",
+ "serde_bencode",
+ "serde_bytes",
+ "sha1_smol",
+ "thiserror 2.0.20",
+ "tracing",
 ]
 
-[[package]]
-name = "macro_rules_attribute-proc_macro"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "670fdfda89751bc4a84ac13eaa63e205cf0fd22b4c9a5fbfa085b63c1f1d3a30"
-
 [[package]]
 name = "markup5ever"
 version = "0.38.0"
@@ -4764,6 +4008,17 @@ dependencies = [
  "web_atoms",
 ]
 
+[[package]]
+name = "match-lookup"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "549e39695cc0b640f3cb378053832db3d2133422d49e8dcae5c866a2aaf1f730"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "matchers"
 version = "0.2.0"
@@ -4773,42 +4028,17 @@ dependencies = [
  "regex-automata",
 ]
 
-[[package]]
-name = "matchit"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e7465ac9959cc2b1404e8e2367b43684a6d13790fe23056cc8c6c5a6b7bcb94"
-
 [[package]]
 name = "matchit"
 version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
 
-[[package]]
-name = "md-5"
-version = "0.10.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
-dependencies = [
- "cfg-if",
- "digest 0.10.7",
-]
-
 [[package]]
 name = "memchr"
-version = "2.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"
-
-[[package]]
-name = "memmap2"
-version = "0.9.8"
+version = "2.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "843a98750cd611cc2965a8213b53b43e715f13c37a9e096c6408e69990961db7"
-dependencies = [
- "libc",
-]
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
 
 [[package]]
 name = "memoffset"
@@ -4820,49 +4050,32 @@ dependencies = [
 ]
 
 [[package]]
-name = "mime"
-version = "0.3.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
-
-[[package]]
-name = "mime_guess"
-version = "2.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e"
-dependencies = [
- "mime",
- "unicase",
-]
-
-[[package]]
-name = "minicov"
-version = "0.3.7"
+name = "miette"
+version = "7.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f27fe9f1cc3c22e1687f9446c2083c4c5fc7f0bcf1c7a86bdbded14985895b4b"
+checksum = "5f98efec8807c63c752b5bd61f862c165c115b0a35685bdcfd9238c7aeb592b7"
 dependencies = [
- "cc",
- "walkdir",
+ "cfg-if",
+ "miette-derive",
+ "unicode-width",
 ]
 
 [[package]]
-name = "minijinja"
-version = "2.12.0"
+name = "miette-derive"
+version = "7.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9f264d75233323f4b7d2f03aefe8a990690cdebfbfe26ea86bcbaec5e9ac990"
+checksum = "db5b29714e950dbb20d5e6f74f9dcec4edbcc1067bb7f8ed198c097b8c1a818b"
 dependencies = [
- "serde",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
 ]
 
 [[package]]
-name = "minijinja-contrib"
-version = "2.12.0"
+name = "mime"
+version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "182ba1438db4679ddfa03792c183bdc2b9ce26b58e7d41a749e59b06497cf136"
-dependencies = [
- "minijinja",
- "serde",
-]
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 
 [[package]]
 name = "minimal-lexical"
@@ -4881,124 +4094,142 @@ dependencies = [
 ]
 
 [[package]]
-name = "mio"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c"
-dependencies = [
- "libc",
- "wasi",
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "mockall"
-version = "0.15.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a6ceddfe3ce334925e96bf420fdb2dcee5bed6c632a168ece622676dadeaf8a"
-dependencies = [
- "cfg-if",
- "downcast",
- "fragile",
- "mockall_derive",
- "predicates",
- "predicates-tree",
-]
-
-[[package]]
-name = "mockall_derive"
-version = "0.15.0"
+name = "miniz_oxide"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cfe16fbe8a314aeec0b861ac24e60b1e123e97634bab045475b9d6a18416fd8"
+checksum = "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c"
 dependencies = [
- "cfg-if",
- "proc-macro2",
- "quote",
- "syn 2.0.106",
+ "adler2",
+ "simd-adler32",
 ]
 
 [[package]]
-name = "moka"
-version = "0.12.10"
+name = "mio"
+version = "1.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9321642ca94a4282428e6ea4af8cc2ca4eac48ac7a6a4ea8f33f76d0ce70926"
+checksum = "4b18443e9c262bfe8fa82f51666e2642c53393f7e5c27b3e1aeab922cff5b9d8"
 dependencies = [
- "crossbeam-channel",
- "crossbeam-epoch",
- "crossbeam-utils",
- "loom",
- "parking_lot",
- "portable-atomic",
- "rustc_version",
- "smallvec",
- "tagptr",
- "thiserror 1.0.69",
- "uuid",
+ "libc",
+ "wasi",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "monostate"
-version = "0.1.14"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aafe1be9d0c75642e3e50fedc7ecadf1ef1cbce6eb66462153fc44245343fbee"
+checksum = "3341a273f6c9d5bef1908f17b7267bbab0e95c9bf69a0d4dcf8e9e1b2c76ef67"
 dependencies = [
  "monostate-impl",
  "serde",
+ "serde_core",
 ]
 
 [[package]]
 name = "monostate-impl"
-version = "0.1.14"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c402a4092d5e204f32c9e155431046831fa712637043c58cb73bc6bc6c9663b5"
+checksum = "e4db6d5580af57bf992f59068d4ea26fd518574ff48d7639b255a36f9de6e7e9"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
 name = "muda"
-version = "0.19.1"
+version = "0.19.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ae8844f63b5b118e334e205585b8c5c17b984121dbdb179d44aeb087ffad3cb"
+checksum = "1dd04e60bc0b07438a6771710ee1698f98f6ebbc7f89b61264af1563b8aeb878"
 dependencies = [
  "crossbeam-channel",
  "dpi",
  "gtk",
  "keyboard-types",
- "objc2 0.6.4",
+ "objc2",
  "objc2-app-kit",
  "objc2-core-foundation",
- "objc2-foundation 0.3.1",
+ "objc2-foundation",
  "once_cell",
  "png 0.18.1",
  "serde",
  "thiserror 2.0.20",
- "windows-sys 0.61.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "n0-error"
+name = "multibase"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e0e4a371cbf1dfd666b658ba137763edb23c45beb43cfe369b5593cd6b437b6"
+dependencies = [
+ "base-x",
+ "base256emoji",
+ "base45",
+ "data-encoding",
+ "data-encoding-macro",
+]
+
+[[package]]
+name = "multihash"
+version = "0.19.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "577c63b00ad74d57e8c9aa870b5fccebf2fd64a308a5aee9f1bb88e4aea19447"
+dependencies = [
+ "serde",
+ "unsigned-varint",
+]
+
+[[package]]
+name = "multimap"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d87ecb2933e8aeadb3e3a02b828fed80a7528047e68b4f424523a0981a3a084"
+
+[[package]]
+name = "n0-dns-resolver"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a4839a11b62f1fdd75be912ee20634053c734c2240e867ded41c7f50822c549"
+checksum = "535c99c9a786bee714155d2ee4fc2477405c2c43536e1bc6a51de09a0d1448f7"
 dependencies = [
  "derive_more",
+ "ipconfig",
+ "jni 0.22.4",
+ "lru 0.18.4",
+ "n0-error",
+ "n0-future",
+ "ndk-context",
+ "rand 0.10.2",
+ "reqwest",
+ "rustc-hash",
+ "rustls",
+ "simple-dns",
+ "system-configuration",
+ "tokio",
+ "tokio-rustls",
+ "tracing",
+ "webpki-roots 1.0.9",
+]
+
+[[package]]
+name = "n0-error"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26c59ea174675ce6bc196878851e5049e11b8b1f9af3ba87e4d6df8d828bb001"
+dependencies = [
  "n0-error-macros",
  "spez",
 ]
 
 [[package]]
 name = "n0-error-macros"
-version = "0.1.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ed2a7e5ca3cb5729d4a162d7bcab5b338bed299a2fee8457568d7e0a747ed89"
+checksum = "4412346410d6616f3668c40e53c298e5320c7b856f7a960e5914e442601be79f"
 dependencies = [
- "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
@@ -5024,40 +4255,23 @@ dependencies = [
 
 [[package]]
 name = "n0-watcher"
-version = "0.5.0"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38acf13c1ddafc60eb7316d52213467f8ccb70b6f02b65e7d97f7799b1f50be4"
+checksum = "bbc618745ad0b7414b149d0517ad8b5573b2fb4d4e2717add3d2446ce1fdd826"
 dependencies = [
  "derive_more",
  "n0-error",
  "n0-future",
 ]
 
-[[package]]
-name = "native-tls"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87de3442987e9dbec73158d5c715e7ad9072fda936bb03d19d7fa10e00520f0e"
-dependencies = [
- "libc",
- "log",
- "openssl",
- "openssl-probe",
- "openssl-sys",
- "schannel",
- "security-framework 2.11.1",
- "security-framework-sys",
- "tempfile",
-]
-
 [[package]]
 name = "ndk"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4"
 dependencies = [
- "bitflags 2.9.4",
- "jni-sys",
+ "bitflags 2.13.2",
+ "jni-sys 0.3.1",
  "log",
  "ndk-sys",
  "num_enum",
@@ -5065,104 +4279,179 @@ dependencies = [
  "thiserror 1.0.69",
 ]
 
+[[package]]
+name = "ndk-context"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b"
+
 [[package]]
 name = "ndk-sys"
 version = "0.6.0+11769913"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873"
 dependencies = [
- "jni-sys",
+ "jni-sys 0.3.1",
 ]
 
 [[package]]
 name = "netdev"
-version = "0.38.2"
+version = "0.45.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67ab878b4c90faf36dab10ea51d48c69ae9019bcca47c048a7c9b273d5d7a823"
+checksum = "096c44b66a9b09b99b4dd36b1c295ff3a492039ccecaf55466bd6ddcdba59968"
 dependencies = [
- "dlopen2 0.5.0",
+ "block2",
+ "dispatch2",
+ "dlopen2",
  "ipnet",
+ "jni 0.21.1",
  "libc",
- "netlink-packet-core",
- "netlink-packet-route",
- "netlink-sys",
+ "mac-addr",
+ "ndk-context",
+ "netlink-packet-core 0.8.2",
+ "netlink-packet-route 0.31.0",
+ "netlink-sys 0.8.8",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-core-wlan",
+ "objc2-foundation",
+ "objc2-system-configuration",
  "once_cell",
- "system-configuration 0.6.1",
- "windows-sys 0.59.0",
+ "plist",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "netdev"
+version = "0.46.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3c52c2584961c68f5a6e3356797344061f818c93b8acc9cd6d7e284795e563e"
+dependencies = [
+ "block2",
+ "dispatch2",
+ "dlopen2",
+ "ipnet",
+ "jni 0.21.1",
+ "libc",
+ "mac-addr",
+ "ndk-context",
+ "netlink-packet-core 0.9.0",
+ "netlink-packet-route 0.33.0",
+ "netlink-sys 0.9.0",
+ "objc2-core-foundation",
+ "objc2-system-configuration",
+ "once_cell",
+ "plist",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "netlink-packet-core"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3463cbb78394cb0141e2c926b93fc2197e473394b761986eca3b9da2c63ae0f4"
+checksum = "b897d7bd4f0af82e68d40d0344cf37e97f9c97ddf74a098de3e4da05e96ca395"
 dependencies = [
  "paste",
 ]
 
+[[package]]
+name = "netlink-packet-core"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d6e2daf9a8c2e21302714706860a0e6be02e03d17294ecc66b354ea7d4059dd"
+
 [[package]]
 name = "netlink-packet-route"
-version = "0.25.1"
+version = "0.31.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2288fcb784eb3defd5fb16f4c4160d5f477de192eac730f43e1d11c24d9a007"
+dependencies = [
+ "bitflags 2.13.2",
+ "libc",
+ "log",
+ "netlink-packet-core 0.8.2",
+]
+
+[[package]]
+name = "netlink-packet-route"
+version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ec2f5b6839be2a19d7fa5aab5bc444380f6311c2b693551cb80f45caaa7b5ef"
+checksum = "59d48ffc8b73a506e1ff0878528c72668f2bfbc3d875b6be890a96be5d0d5576"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.13.2",
  "libc",
  "log",
- "netlink-packet-core",
+ "netlink-packet-core 0.9.0",
+ "zerocopy",
 ]
 
 [[package]]
 name = "netlink-proto"
-version = "0.12.0"
+version = "0.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b65d130ee111430e47eed7896ea43ca693c387f097dd97376bffafbf25812128"
+checksum = "93af8261786086024cd5e96e0a991dd65ced07bbf7c233a487bbc96b971d5539"
 dependencies = [
  "bytes",
- "futures",
+ "futures-channel",
+ "futures-util",
  "log",
- "netlink-packet-core",
- "netlink-sys",
+ "netlink-packet-core 0.8.2",
+ "netlink-sys 0.8.8",
  "thiserror 2.0.20",
 ]
 
 [[package]]
 name = "netlink-sys"
-version = "0.8.7"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16c903aa70590cb93691bf97a767c8d1d6122d2cc9070433deb3bbf36ce8bd23"
+checksum = "cd6c30ed10fa69cc491d491b85cc971f6bdeb8e7367b7cde2ee6cc878d583fae"
 dependencies = [
  "bytes",
- "futures",
+ "futures-util",
  "libc",
  "log",
  "tokio",
 ]
 
+[[package]]
+name = "netlink-sys"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c99d38e00b420df49e940fe0826e667c3dad82ac68eb4c2bbf754c1c14a83a10"
+dependencies = [
+ "bytes",
+ "libc",
+ "log",
+]
+
 [[package]]
 name = "netwatch"
-version = "0.12.0"
+version = "0.19.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26f2acd376ef48b6c326abf3ba23c449e0cb8aa5c2511d189dd8a8a3bfac889b"
+checksum = "39da9cad5f23aa43401f09497d3b280e51b5feba115d9ffbf38ca35d6ff95e96"
 dependencies = [
  "atomic-waker",
  "bytes",
  "cfg_aliases",
  "derive_more",
- "iroh-quinn-udp",
+ "ipnet",
  "js-sys",
  "libc",
  "n0-error",
  "n0-future",
  "n0-watcher",
- "netdev",
- "netlink-packet-core",
- "netlink-packet-route",
+ "netdev 0.45.1",
+ "netdev 0.46.3",
+ "netlink-packet-core 0.8.2",
+ "netlink-packet-route 0.31.0",
  "netlink-proto",
- "netlink-sys",
+ "netlink-sys 0.8.8",
+ "noq-udp",
+ "objc2-core-foundation",
+ "objc2-system-configuration",
  "pin-project-lite",
  "serde",
- "socket2 0.6.0",
+ "socket2",
  "time",
  "tokio",
  "tokio-util",
@@ -5180,111 +4469,118 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
 
 [[package]]
-name = "nix"
-version = "0.30.1"
+name = "nom"
+version = "7.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
 dependencies = [
- "bitflags 2.9.4",
- "cfg-if",
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "noq"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b78be567e796cfa74bb9bdc4117790af2d505eb887019cf8803244353eb09d89"
+dependencies = [
+ "bytes",
  "cfg_aliases",
- "libc",
- "memoffset",
+ "derive_more",
+ "noq-proto",
+ "noq-udp",
+ "pin-project-lite",
+ "rustc-hash",
+ "rustls",
+ "socket2",
+ "thiserror 2.0.20",
+ "tokio",
+ "tokio-stream",
+ "tracing",
+ "web-time",
 ]
 
 [[package]]
-name = "nom"
-version = "7.1.3"
+name = "noq-proto"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+checksum = "7c1e5b6fe668491eca022f745a0a9402585626c73a7b839b3424ace15d6a9c8f"
 dependencies = [
- "memchr",
- "minimal-lexical",
+ "aes-gcm",
+ "bytes",
+ "derive_more",
+ "enum-assoc",
+ "getrandom 0.4.3",
+ "identity-hash",
+ "lru-slab",
+ "rand 0.10.2",
+ "rand_pcg",
+ "ring",
+ "rustc-hash",
+ "rustls",
+ "rustls-pki-types",
+ "slab",
+ "sorted-index-buffer",
+ "thiserror 2.0.20",
+ "tinyvec",
+ "tracing",
+ "web-time",
 ]
 
 [[package]]
-name = "ntimestamp"
-version = "1.0.0"
+name = "noq-udp"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c50f94c405726d3e0095e89e72f75ce7f6587b94a8bd8dc8054b73f65c0fd68c"
+checksum = "4dc50afea61aff926e150a36c31f06094608848e114a3fe667d76ec233163b1c"
 dependencies = [
- "base32",
- "document-features",
- "getrandom 0.2.16",
- "httpdate",
- "js-sys",
- "once_cell",
- "serde",
+ "cfg_aliases",
+ "libc",
+ "socket2",
+ "tracing",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "nu-ansi-term"
-version = "0.50.1"
+version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4a28e057d01f97e61255210fcff094d74ed0466038633e95017f5beb68e4399"
+checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "num-bigint"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
-dependencies = [
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "num-bigint-dig"
-version = "0.8.4"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc84195820f291c7697304f3cbdadd1cb7199c0efc917ff5eafd71225c136151"
+checksum = "c89e69e7e0f03bea5ef08013795c25018e101932225a656383bd384495ecc367"
 dependencies = [
- "byteorder",
- "lazy_static",
- "libm",
  "num-integer",
- "num-iter",
- "num-traits",
- "rand 0.8.8",
- "smallvec",
- "zeroize",
-]
-
-[[package]]
-name = "num-complex"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
-dependencies = [
- "bytemuck",
  "num-traits",
 ]
 
 [[package]]
 name = "num-conv"
-version = "0.1.0"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441"
 
 [[package]]
 name = "num-integer"
-version = "0.1.46"
+version = "0.1.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b"
 dependencies = [
  "num-traits",
 ]
 
 [[package]]
-name = "num-iter"
-version = "0.1.45"
+name = "num-rational"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
 dependencies = [
- "autocfg",
+ "num-bigint",
  "num-integer",
  "num-traits",
 ]
@@ -5296,7 +4592,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
 dependencies = [
  "autocfg",
- "libm",
 ]
 
 [[package]]
@@ -5311,9 +4606,9 @@ dependencies = [
 
 [[package]]
 name = "num_enum"
-version = "0.7.4"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a973b4e44ce6cad84ce69d797acf9a044532e4184c4f267913d1b546a0727b7a"
+checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26"
 dependencies = [
  "num_enum_derive",
  "rustversion",
@@ -5321,36 +4616,14 @@ dependencies = [
 
 [[package]]
 name = "num_enum_derive"
-version = "0.7.4"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77e878c846a8abae00dd069496dbe8751b16ac1c3d6bd2a7283a938e8228f90d"
+checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8"
 dependencies = [
- "proc-macro-crate 3.3.0",
+ "proc-macro-crate 3.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
-]
-
-[[package]]
-name = "number_prefix"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"
-
-[[package]]
-name = "objc-sys"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdb91bdd390c7ce1a8607f35f3ca7151b65afc0ff5ff3b34fa350f7d7c7e4310"
-
-[[package]]
-name = "objc2"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46a785d4eeff09c14c487497c162e92766fbb3e4059a71840cecc03d9a50b804"
-dependencies = [
- "objc-sys",
- "objc2-encode",
+ "syn 2.0.119",
 ]
 
 [[package]]
@@ -5365,80 +4638,108 @@ dependencies = [
 
 [[package]]
 name = "objc2-app-kit"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6f29f568bec459b0ddff777cec4fe3fd8666d82d5a40ebd0ff7e66134f89bcc"
+checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c"
 dependencies = [
- "bitflags 2.9.4",
- "block2 0.6.1",
- "objc2 0.6.4",
+ "bitflags 2.13.2",
+ "block2",
+ "objc2",
  "objc2-core-foundation",
- "objc2-foundation 0.3.1",
+ "objc2-foundation",
 ]
 
 [[package]]
 name = "objc2-cloud-kit"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17614fdcd9b411e6ff1117dfb1d0150f908ba83a7df81b1f118005fe0a8ea15d"
+checksum = "73ad74d880bb43877038da939b7427bba67e9dd42004a18b809ba7d87cee241c"
 dependencies = [
- "bitflags 2.9.4",
- "objc2 0.6.4",
- "objc2-foundation 0.3.1",
+ "bitflags 2.13.2",
+ "objc2",
+ "objc2-foundation",
 ]
 
 [[package]]
 name = "objc2-core-data"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "291fbbf7d29287518e8686417cf7239c74700fd4b607623140a7d4a3c834329d"
+checksum = "0b402a653efbb5e82ce4df10683b6b28027616a2715e90009947d50b8dd298fa"
 dependencies = [
- "objc2 0.6.4",
- "objc2-foundation 0.3.1",
+ "objc2",
+ "objc2-foundation",
 ]
 
 [[package]]
 name = "objc2-core-foundation"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c10c2894a6fed806ade6027bcd50662746363a9589d3ec9d9bef30a4e4bc166"
+checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.13.2",
+ "block2",
  "dispatch2",
- "objc2 0.6.4",
+ "libc",
+ "objc2",
 ]
 
 [[package]]
 name = "objc2-core-graphics"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "989c6c68c13021b5c2d6b71456ebb0f9dc78d752e86a98da7c716f4f9470f5a4"
+checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.13.2",
  "dispatch2",
- "objc2 0.6.4",
+ "objc2",
  "objc2-core-foundation",
  "objc2-io-surface",
 ]
 
 [[package]]
 name = "objc2-core-image"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79b3dc0cc4386b6ccf21c157591b34a7f44c8e75b064f85502901ab2188c007e"
+checksum = "e5d563b38d2b97209f8e861173de434bd0214cf020e3423a52624cd1d989f006"
 dependencies = [
- "objc2 0.6.4",
- "objc2-foundation 0.3.1",
+ "objc2",
+ "objc2-foundation",
 ]
 
 [[package]]
 name = "objc2-core-location"
-version = "0.3.1"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca347214e24bc973fc025fd0d36ebb179ff30536ed1f80252706db19ee452009"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-text"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cde0dfb48d25d2b4862161a4d5fcc0e3c24367869ad306b0c9ec0073bfed92d"
+dependencies = [
+ "bitflags 2.13.2",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+]
+
+[[package]]
+name = "objc2-core-wlan"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac0f75792558aa9d618443bbb5db7426a7a0b6fddf96903f86ef9ad02e135740"
+checksum = "c71e34919aba0d701380d911702455038a8a3587467fe0141d6a71501e7ffe48"
 dependencies = [
- "objc2 0.6.4",
- "objc2-foundation 0.3.1",
+ "bitflags 2.13.2",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "objc2-security",
+ "objc2-security-foundation",
 ]
 
 [[package]]
@@ -5458,136 +4759,118 @@ dependencies = [
 
 [[package]]
 name = "objc2-foundation"
-version = "0.2.2"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ee638a5da3799329310ad4cfa62fbf045d5f56e3ef5ba4149e7452dcf89d5a8"
+checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272"
 dependencies = [
- "bitflags 2.9.4",
- "block2 0.5.1",
+ "bitflags 2.13.2",
+ "block2",
  "libc",
- "objc2 0.5.2",
+ "objc2",
+ "objc2-core-foundation",
 ]
 
 [[package]]
-name = "objc2-foundation"
-version = "0.3.1"
+name = "objc2-io-surface"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "900831247d2fe1a09a683278e5384cfb8c80c79fe6b166f9d14bfdde0ea1b03c"
+checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d"
 dependencies = [
- "bitflags 2.9.4",
- "block2 0.6.1",
- "objc2 0.6.4",
+ "bitflags 2.13.2",
+ "objc2",
  "objc2-core-foundation",
 ]
 
 [[package]]
-name = "objc2-io-surface"
-version = "0.3.1"
+name = "objc2-quartz-core"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7282e9ac92529fa3457ce90ebb15f4ecbc383e8338060960760fa2cf75420c3c"
+checksum = "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f"
 dependencies = [
- "bitflags 2.9.4",
- "objc2 0.6.4",
+ "bitflags 2.13.2",
+ "objc2",
  "objc2-core-foundation",
+ "objc2-foundation",
 ]
 
 [[package]]
-name = "objc2-metal"
-version = "0.2.2"
+name = "objc2-security"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd0cba1276f6023976a406a14ffa85e1fdd19df6b0f737b063b95f6c8c7aadd6"
+checksum = "709fe137109bd1e8b5a99390f77a7d8b2961dafc1a1c5db8f2e60329ad6d895a"
 dependencies = [
- "bitflags 2.9.4",
- "block2 0.5.1",
- "objc2 0.5.2",
- "objc2-foundation 0.2.2",
+ "bitflags 2.13.2",
+ "objc2",
+ "objc2-core-foundation",
 ]
 
 [[package]]
-name = "objc2-quartz-core"
-version = "0.2.2"
+name = "objc2-security-foundation"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e42bee7bff906b14b167da2bac5efe6b6a07e6f7c0a21a7308d40c960242dc7a"
+checksum = "ef76382e9cedd18123099f17638715cc3d81dba3637d4c0d39ab69df2ef345a5"
 dependencies = [
- "bitflags 2.9.4",
- "block2 0.5.1",
- "objc2 0.5.2",
- "objc2-foundation 0.2.2",
- "objc2-metal",
+ "objc2",
+ "objc2-foundation",
 ]
 
 [[package]]
-name = "objc2-quartz-core"
-version = "0.3.1"
+name = "objc2-system-configuration"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90ffb6a0cd5f182dc964334388560b12a57f7b74b3e2dec5e2722aa2dfb2ccd5"
+checksum = "7216bd11cbda54ccabcab84d523dc93b858ec75ecfb3a7d89513fa22464da396"
 dependencies = [
- "bitflags 2.9.4",
- "objc2 0.6.4",
+ "bitflags 2.13.2",
+ "dispatch2",
+ "libc",
+ "objc2",
  "objc2-core-foundation",
- "objc2-foundation 0.3.1",
+ "objc2-security",
 ]
 
 [[package]]
 name = "objc2-ui-kit"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25b1312ad7bc8a0e92adae17aa10f90aae1fb618832f9b993b022b591027daed"
+checksum = "d87d638e33c06f577498cbcc50491496a3ed4246998a7fbba7ccb98b1e7eab22"
 dependencies = [
- "bitflags 2.9.4",
- "block2 0.6.1",
- "objc2 0.6.4",
+ "bitflags 2.13.2",
+ "block2",
+ "objc2",
  "objc2-cloud-kit",
  "objc2-core-data",
  "objc2-core-foundation",
  "objc2-core-graphics",
  "objc2-core-image",
  "objc2-core-location",
- "objc2-foundation 0.3.1",
- "objc2-quartz-core 0.3.1",
+ "objc2-core-text",
+ "objc2-foundation",
+ "objc2-quartz-core",
  "objc2-user-notifications",
 ]
 
 [[package]]
 name = "objc2-user-notifications"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a3f5ec77a81d9e0c5a0b32159b0cb143d7086165e79708351e02bf37dfc65cd"
+checksum = "9df9128cbbfef73cda168416ccf7f837b62737d748333bfe9ab71c245d76613e"
 dependencies = [
- "objc2 0.6.4",
- "objc2-foundation 0.3.1",
+ "objc2",
+ "objc2-foundation",
 ]
 
 [[package]]
 name = "objc2-web-kit"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91672909de8b1ce1c2252e95bbee8c1649c9ad9d14b9248b3d7b4c47903c47ad"
+checksum = "b2e5aaab980c433cf470df9d7af96a7b46a9d892d521a2cbbb2f8a4c16751e7f"
 dependencies = [
- "bitflags 2.9.4",
- "block2 0.6.1",
- "objc2 0.6.4",
+ "bitflags 2.13.2",
+ "block2",
+ "objc2",
  "objc2-app-kit",
  "objc2-core-foundation",
- "objc2-foundation 0.3.1",
-]
-
-[[package]]
-name = "oid-registry"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8d8034d9489cdaf79228eb9f6a3b8d7bb32ba00d6645ebd48eef4077ceb5bd9"
-dependencies = [
- "asn1-rs 0.6.2",
-]
-
-[[package]]
-name = "oid-registry"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12f40cff3dde1b6087cc5d5f5d4d65712f34016a03ed60e9c08dcc392736b5b7"
-dependencies = [
- "asn1-rs 0.7.1",
+ "objc2-foundation",
 ]
 
 [[package]]
@@ -5600,19 +4883,13 @@ dependencies = [
  "portable-atomic",
 ]
 
-[[package]]
-name = "once_cell_polyfill"
-version = "1.70.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad"
-
 [[package]]
 name = "onig"
-version = "6.5.1"
+version = "6.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "336b9c63443aceef14bea841b899035ae3abe89b7c486aaf4c5bd8aafedac3f0"
+checksum = "0cc3cbf698f9438986c11a880c90a6d04b9de27575afd28bbf45b154b6c709e2"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.13.2",
  "libc",
  "once_cell",
  "onig_sys",
@@ -5620,148 +4897,25 @@ dependencies = [
 
 [[package]]
 name = "onig_sys"
-version = "69.9.1"
+version = "69.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7f86c6eef3d6df15f23bcfb6af487cbd2fed4e5581d58d5bf1f5f8b7f6727dc"
+checksum = "1e68317604e77e53b85896388e1a803c1d21b74c899ec9e5e1112db90735edd7"
 dependencies = [
  "cc",
  "pkg-config",
 ]
 
 [[package]]
-name = "open"
-version = "5.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2483562e62ea94312f3576a7aca397306df7990b8d89033e18766744377ef95"
-dependencies = [
- "dunce",
- "is-wsl",
- "libc",
- "pathdiff",
-]
-
-[[package]]
-name = "open-hypergraphs"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5bf4628a77ba91c60f7fc64bc08b80052f9517bcba48ba3aa71f10e7cb1bbe7"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
-name = "openssl"
-version = "0.10.81"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77823a27f0babb03091cb9ed9ef80af3b39dbc82f97e8fa530374b7dafd87a45"
-dependencies = [
- "bitflags 2.9.4",
- "cfg-if",
- "foreign-types 0.3.2",
- "libc",
- "openssl-macros",
- "openssl-sys",
-]
-
-[[package]]
-name = "openssl-macros"
-version = "0.1.1"
+name = "opaque-debug"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.106",
-]
+checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
 
 [[package]]
 name = "openssl-probe"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
-
-[[package]]
-name = "openssl-sys"
-version = "0.9.117"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b47e7e6bb2c38cd930d25a23b40fa52e068c10e85f3e03a7f5ba5aaca5713695"
-dependencies = [
- "cc",
- "libc",
- "pkg-config",
- "vcpkg",
-]
-
-[[package]]
-name = "opentelemetry"
-version = "0.32.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0142c63252a9e054e68a4c61a5778f7b14f576274d593f8ce883d191a099682"
-dependencies = [
- "futures-core",
- "futures-sink",
- "js-sys",
- "pin-project-lite",
- "thiserror 2.0.20",
-]
-
-[[package]]
-name = "opentelemetry-http"
-version = "0.32.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5683015d09e2df236ef005b17f6f196f0d5f6313c4fa43a7b6a53b52776e4331"
-dependencies = [
- "async-trait",
- "bytes",
- "http 1.5.0",
- "opentelemetry",
- "reqwest 0.13.1",
-]
-
-[[package]]
-name = "opentelemetry-otlp"
-version = "0.32.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9966929966d17620d7c316c643ba62631826e10021409357772d5eea84f62c35"
-dependencies = [
- "http 1.5.0",
- "opentelemetry",
- "opentelemetry-http",
- "opentelemetry-proto",
- "opentelemetry_sdk",
- "prost",
- "reqwest 0.13.1",
- "thiserror 2.0.20",
-]
-
-[[package]]
-name = "opentelemetry-proto"
-version = "0.32.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56d658ba1faf63f7b9c492cfbe6e0ec365440a16132d3270c1065f7b33f1b638"
-dependencies = [
- "opentelemetry",
- "opentelemetry_sdk",
- "prost",
-]
-
-[[package]]
-name = "opentelemetry_sdk"
-version = "0.32.1"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b59f80e1ac4d5ff7a2db8fb6c80badb7f0f3f858211fba08dd9aaec750894f9"
-dependencies = [
- "futures-channel",
- "futures-executor",
- "futures-util",
- "opentelemetry",
- "percent-encoding",
- "portable-atomic",
- "rand 0.9.5",
- "thiserror 2.0.20",
- "tokio",
- "tokio-stream",
-]
+checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
 
 [[package]]
 name = "option-ext"
@@ -5770,23 +4924,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
 [[package]]
-name = "ordered-multimap"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49203cdcae0030493bad186b28da2fa25645fa276a51b6fec8010d281e02ef79"
-dependencies = [
- "dlv-list",
- "hashbrown 0.14.5",
-]
-
-[[package]]
-name = "ordered-stream"
-version = "0.2.0"
+name = "p256"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50"
+checksum = "d2c9239b2dbc807adbbe147e8cf72ea7450c3a0aabe62cb8e75ff4ec22e1f72a"
 dependencies = [
- "futures-core",
- "pin-project-lite",
+ "ecdsa 0.17.0",
+ "elliptic-curve 0.14.1",
+ "primefield",
+ "primeorder",
+ "sha2 0.11.0",
 ]
 
 [[package]]
@@ -5814,6 +4961,16 @@ dependencies = [
  "system-deps",
 ]
 
+[[package]]
+name = "papaya"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da2442474a9404698c42509b8967f437249dbc7b50493e83020333d3943ec0ae"
+dependencies = [
+ "equivalent",
+ "seize",
+]
+
 [[package]]
 name = "parking"
 version = "2.2.1"
@@ -5822,9 +4979,9 @@ checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
 
 [[package]]
 name = "parking_lot"
-version = "0.12.4"
+version = "0.12.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70d58bf43669b5795d1576d0641cfb6fbb2057bf629506267a92807158584a13"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
 dependencies = [
  "lock_api",
  "parking_lot_core",
@@ -5832,15 +4989,15 @@ dependencies = [
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.11"
+version = "0.9.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc838d2a56b5b1a6c25f55575dfc605fabb63bb2365f6c2353ef9159aa69e4a5"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
 dependencies = [
  "cfg-if",
  "libc",
  "redox_syscall",
  "smallvec",
- "windows-targets 0.52.6",
+ "windows-link 0.2.1",
 ]
 
 [[package]]
@@ -5850,51 +5007,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
 [[package]]
-name = "pastey"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35fb2e5f958ec131621fdd531e9fc186ed768cbe395337403ae56c17a74c68ec"
-
-[[package]]
-name = "pathdiff"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3"
-
-[[package]]
-name = "pem"
-version = "3.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38af38e8470ac9dee3ce1bae1af9c1671fffc44ddfd8bd1d0a3445bf349a8ef3"
-dependencies = [
- "base64 0.22.1",
- "serde",
-]
-
-[[package]]
-name = "pem"
-version = "4.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d354a98a3d1251555de99e8fdd8afda05573c31b82f59063a7b0a29b5527f120"
-dependencies = [
- "base64 0.23.1",
- "serde_core",
-]
-
-[[package]]
-name = "pem-rfc7468"
-version = "0.7.0"
+name = "pastey"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
-dependencies = [
- "base64ct",
-]
+checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4"
 
 [[package]]
 name = "pem-rfc7468"
-version = "1.0.0-rc.3"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8e58fab693c712c0d4e88f8eb3087b6521d060bcaf76aeb20cb192d809115ba"
+checksum = "a6305423e0e7738146434843d1694d621cce767262b2a86910beab705e4493d9"
 dependencies = [
  "base64ct",
 ]
@@ -5906,47 +5028,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
 [[package]]
-name = "pest"
-version = "2.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1db05f56d34358a8b1066f67cbb203ee3e7ed2ba674a6263a1d5ec6db2204323"
-dependencies = [
- "memchr",
- "thiserror 2.0.20",
- "ucd-trie",
-]
-
-[[package]]
-name = "pest_derive"
-version = "2.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb056d9e8ea77922845ec74a1c4e8fb17e7c218cc4fc11a15c5d25e189aa40bc"
-dependencies = [
- "pest",
- "pest_generator",
-]
-
-[[package]]
-name = "pest_generator"
-version = "2.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87e404e638f781eb3202dc82db6760c8ae8a1eeef7fb3fa8264b2ef280504966"
-dependencies = [
- "pest",
- "pest_meta",
- "proc-macro2",
- "quote",
- "syn 2.0.106",
-]
-
-[[package]]
-name = "pest_meta"
-version = "2.8.1"
+name = "petgraph"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edd1101f170f5903fde0914f899bb503d9ff5271d7ba76bbb70bea63690cc0d5"
+checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
 dependencies = [
- "pest",
- "sha2 0.10.9",
+ "fixedbitset",
+ "hashbrown 0.15.5",
+ "indexmap 2.14.2",
 ]
 
 [[package]]
@@ -6000,7 +5089,7 @@ dependencies = [
  "phf_shared",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
@@ -6014,93 +5103,29 @@ dependencies = [
 
 [[package]]
 name = "pin-project"
-version = "1.1.10"
+version = "1.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677f1add503faace112b9f1373e43e9e054bfdd22ff1a63c1bc485eaec6a6a8a"
+checksum = "2466b2336ed02bcdca6b294417127b90ec92038d1d5c4fbeac971a922e0e0924"
 dependencies = [
  "pin-project-internal",
 ]
 
 [[package]]
 name = "pin-project-internal"
-version = "1.1.10"
+version = "1.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
+checksum = "c96395f0a926bc13b1c17622aaddda1ecb55d49c8f1bf9777e4d877800a43f8b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
-
-[[package]]
-name = "pinned"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a829027bd95e54cfe13e3e258a1ae7b645960553fb82b75ff852c29688ee595b"
-dependencies = [
- "futures",
- "rustversion",
- "thiserror 1.0.69",
-]
-
-[[package]]
-name = "piper"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96c8c490f422ef9a4efd2cb5b42b76c8613d7e7dfc1caf667b8a3350a5acc066"
-dependencies = [
- "atomic-waker",
- "fastrand",
- "futures-io",
-]
-
-[[package]]
-name = "pkarr"
-version = "5.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "792c1328860f6874e90e3b387b4929819cc7783a6bd5a4728e918706eb436a48"
-dependencies = [
- "async-compat",
- "base32",
- "bytes",
- "cfg_aliases",
- "document-features",
- "dyn-clone",
- "ed25519-dalek",
- "futures-buffered",
- "futures-lite",
- "getrandom 0.3.4",
- "log",
- "lru 0.13.0",
- "ntimestamp",
- "reqwest 0.12.28",
- "self_cell",
- "serde",
- "sha1_smol",
- "simple-dns",
- "thiserror 2.0.20",
- "tokio",
- "tracing",
- "url",
- "wasm-bindgen-futures",
-]
-
-[[package]]
-name = "pkcs1"
-version = "0.7.5"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8ffb9f10fa047879315e6625af03c164b16962a5368d724ed16323b68ace47f"
-dependencies = [
- "der 0.7.10",
- "pkcs8 0.10.2",
- "spki 0.7.3",
-]
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 
 [[package]]
 name = "pkcs8"
@@ -6114,28 +5139,28 @@ dependencies = [
 
 [[package]]
 name = "pkcs8"
-version = "0.11.0-rc.7"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93eac55f10aceed84769df670ea4a32d2ffad7399400d41ee1c13b1cd8e1b478"
+checksum = "451913da69c775a56034ea8d9003d27ee8948e12443eae7c038ba100a4f21cb7"
 dependencies = [
- "der 0.8.0-rc.9",
- "spki 0.8.0-rc.4",
+ "der 0.8.2",
+ "spki 0.8.0",
 ]
 
 [[package]]
 name = "pkg-config"
-version = "0.3.32"
+version = "0.3.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548"
 
 [[package]]
 name = "plist"
-version = "1.7.4"
+version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3af6b589e163c5a788fab00ce0c0366f6efbb9959c2f9874b224936af7fce7e1"
+checksum = "2896bade328c13f7042a297ea5ac5b0951f6cf989dea5f32c2fd98da398195cb"
 dependencies = [
- "base64 0.22.1",
- "indexmap 2.12.0",
+ "base64 0.23.1",
+ "indexmap 2.14.2",
  "quick-xml",
  "serde",
  "time",
@@ -6151,7 +5176,7 @@ dependencies = [
  "crc32fast",
  "fdeflate",
  "flate2",
- "miniz_oxide",
+ "miniz_oxide 0.8.9",
 ]
 
 [[package]]
@@ -6160,65 +5185,74 @@ version = "0.18.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.13.2",
  "crc32fast",
  "fdeflate",
  "flate2",
- "miniz_oxide",
+ "miniz_oxide 0.8.9",
 ]
 
 [[package]]
-name = "polling"
-version = "3.10.0"
+name = "poly1305"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5bd19146350fe804f7cb2669c851c03d69da628803dab0d98018142aaa5d829"
+checksum = "6e2d0073b297041425c7c3df6eb4792d598a15323fe63346852b092eca02904c"
 dependencies = [
- "cfg-if",
- "concurrent-queue",
- "hermit-abi",
- "pin-project-lite",
- "rustix",
- "windows-sys 0.60.2",
+ "cpufeatures 0.3.1",
+ "universal-hash 0.6.1",
 ]
 
 [[package]]
-name = "poly1305"
-version = "0.9.0-rc.2"
+name = "polyval"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb78a635f75d76d856374961deecf61031c0b6f928c83dc9c0924ab6c019c298"
+checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25"
 dependencies = [
- "cpufeatures",
- "universal-hash",
+ "cfg-if",
+ "cpufeatures 0.2.17",
+ "opaque-debug",
+ "universal-hash 0.5.1",
 ]
 
 [[package]]
 name = "portable-atomic"
-version = "1.11.1"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
+checksum = "10ab3eb7f3becc3a1cbc4f2c6f20267996cfc1a6467a873763411b136a122715"
+dependencies = [
+ "portable-atomic",
+]
 
 [[package]]
 name = "portmapper"
-version = "0.12.0"
+version = "0.19.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b575f975dcf03e258b0c7ab3f81497d7124f508884c37da66a7314aa2a8d467"
+checksum = "ca97242f016e090a25330613bc2382aab65eb22f9149dbe84d8f8e711d49a530"
 dependencies = [
  "base64 0.22.1",
  "bytes",
  "derive_more",
- "futures-lite",
- "futures-util",
  "hyper-util",
  "igd-next",
  "iroh-metrics",
  "libc",
  "n0-error",
+ "n0-future",
  "netwatch",
  "num_enum",
- "rand 0.9.5",
+ "rand 0.10.2",
  "serde",
  "smallvec",
- "socket2 0.6.0",
+ "socket2",
  "time",
  "tokio",
  "tokio-util",
@@ -6236,7 +5270,6 @@ dependencies = [
  "cobs",
  "embedded-io 0.4.0",
  "embedded-io 0.6.1",
- "heapless",
  "postcard-derive",
  "serde",
 ]
@@ -6249,14 +5282,14 @@ checksum = "e0232bd009a197ceec9cc881ba46f727fcd8060a2d8d6a9dde7a69030a6fe2bb"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
 name = "potential_utf"
-version = "0.1.3"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84df19adbe5b5a0782edcab45899906947ab039ccf4573713735ee7de1e6b08a"
+checksum = "d83eb9bc6d8e5cf568e7a1101d60ee05e81ed50ea106026f3d18deeb046d7661"
 dependencies = [
  "zerovec",
 ]
@@ -6283,39 +5316,40 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
 
 [[package]]
-name = "predicates"
-version = "3.1.3"
+name = "prettyplease"
+version = "0.2.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5d19ee57562043d37e82899fade9a22ebab7be9cef5026b07fda9cdd4293573"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
 dependencies = [
- "anstyle",
- "predicates-core",
+ "proc-macro2",
+ "syn 2.0.119",
 ]
 
 [[package]]
-name = "predicates-core"
-version = "1.0.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "727e462b119fe9c93fd0eb1429a5f7647394014cf3c04ab2c0350eeb09095ffa"
-
-[[package]]
-name = "predicates-tree"
-version = "1.0.12"
+name = "primefield"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72dd2d6d381dfb73a193c7fca536518d7caee39fc8503f74e7dc0be0531b425c"
+checksum = "c555a6e4eb7d4e158fcb028c835c3b8642206ddc279b5c6b202ef9a8bdb592f4"
 dependencies = [
- "predicates-core",
- "termtree",
+ "crypto-bigint 0.7.5",
+ "crypto-common 0.2.2",
+ "ff 0.14.0",
+ "rand_core 0.10.1",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
-name = "prettyplease"
-version = "0.2.37"
+name = "primeorder"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+checksum = "5c9f42978c78a00e3d68f69fc03e57a234debae69da4020a4fb588fcdcd07b06"
 dependencies = [
- "proc-macro2",
- "syn 2.0.106",
+ "elliptic-curve 0.14.1",
+ "once_cell",
+ "primefield",
+ "serdect",
+ "wnaf",
 ]
 
 [[package]]
@@ -6330,20 +5364,21 @@ dependencies = [
 
 [[package]]
 name = "proc-macro-crate"
-version = "2.0.0"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e8366a6159044a37876a2b9817124296703c586a5c92e2c53751fa06d8d43e8"
+checksum = "b00f26d3400549137f92511a46ac1cd8ce37cb5598a96d382381458b992a5d24"
 dependencies = [
- "toml_edit 0.20.7",
+ "toml_datetime 0.6.3",
+ "toml_edit 0.20.2",
 ]
 
 [[package]]
 name = "proc-macro-crate"
-version = "3.3.0"
+version = "3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edce586971a4dfaa28950c6f18ed55e0406c1ab88bbce2c6f6293a7aaba73d35"
+checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
 dependencies = [
- "toml_edit 0.22.27",
+ "toml_edit 0.25.15+spec-1.1.0",
 ]
 
 [[package]]
@@ -6379,57 +5414,148 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "prometheus-client"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1784dc11a05f5a8f57c4a62915686be140f24f70301290b997e317241fa9ffc2"
+dependencies = [
+ "dtoa",
+ "itoa",
+ "parking_lot",
+ "prometheus-client-derive-encode",
+]
+
+[[package]]
+name = "prometheus-client-derive-encode"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01e34894696ff94f64a20c2c373a6440903e9c2789a303d68ec6e6f953f890e4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.5",
+]
+
+[[package]]
+name = "proptest"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b45fcc2344c680f5025fe57779faef368840d0bd1f42f216291f0dc4ace4744"
+dependencies = [
+ "bitflags 2.13.2",
+ "num-traits",
+ "rand 0.9.5",
+ "rand_chacha 0.9.0",
+ "rand_xorshift",
+ "regex-syntax",
+ "unarray",
+]
+
 [[package]]
 name = "prost"
-version = "0.14.1"
+version = "0.14.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7231bd9b3d3d33c86b58adbac74b5ec0ad9f496b19d22801d773636feaa95f3d"
+checksum = "528ac67416ff8646872a3c02cad9cc4ee5dc9f9540c9b10771855c95cb2e5ae1"
 dependencies = [
  "bytes",
  "prost-derive",
 ]
 
+[[package]]
+name = "prost-build"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03da047801ff44bb6a4d407d4860c05fd70bb81714e6b2f3812603d5b145b042"
+dependencies = [
+ "heck 0.5.0",
+ "itertools",
+ "log",
+ "multimap",
+ "petgraph",
+ "prettyplease",
+ "prost",
+ "prost-types",
+ "regex",
+ "syn 2.0.119",
+ "tempfile",
+]
+
 [[package]]
 name = "prost-derive"
-version = "0.14.1"
+version = "0.14.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9120690fafc389a67ba3803df527d0ec9cbbc9cc45e4cc20b332996dfb672425"
+checksum = "b570b25f7617e43d59005d0990ccb79e950a423952cea19671b7a876da390adf"
 dependencies = [
  "anyhow",
  "itertools",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
-name = "pulp"
-version = "0.21.5"
+name = "prost-reflect"
+version = "0.16.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96b86df24f0a7ddd5e4b95c94fc9ed8a98f1ca94d3b01bdce2824097e7835907"
+checksum = "01b80ea363c31af2de2b92e3c07ed1156628f7838c4afb4df75ee78a37fedbd1"
 dependencies = [
- "bytemuck",
- "cfg-if",
- "libm",
- "num-complex",
- "reborrow",
- "version_check",
+ "logos 0.16.1",
+ "miette",
+ "prost",
+ "prost-types",
+]
+
+[[package]]
+name = "prost-types"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f94967dc7688f3054c7fac87473ffae4cc4c3904800e2d9f5b857246d8963b0a"
+dependencies = [
+ "prost",
+]
+
+[[package]]
+name = "protox"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f25a07a73c6717f0b9bbbd685918f5df9815f7efba450b83d9c9dea41f0e3a1"
+dependencies = [
+ "bytes",
+ "miette",
+ "prost",
+ "prost-reflect",
+ "prost-types",
+ "protox-parse",
+ "thiserror 2.0.20",
+]
+
+[[package]]
+name = "protox-parse"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "072eee358134396a4643dff81cfff1c255c9fbd3fb296be14bdb6a26f9156366"
+dependencies = [
+ "logos 0.15.1",
+ "miette",
+ "prost-types",
+ "thiserror 2.0.20",
 ]
 
 [[package]]
 name = "quick-xml"
-version = "0.38.3"
+version = "0.42.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42a232e7487fc2ef313d96dde7948e7a3c05101870d8985e4fd8d26aedd27b89"
+checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "quinn"
-version = "0.11.9"
+version = "0.11.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20"
+checksum = "4051e23e9185c255a7e33ef59cdbca87a22d359052eecd22fc6b901fb37d9d11"
 dependencies = [
  "bytes",
  "cfg_aliases",
@@ -6438,7 +5564,7 @@ dependencies = [
  "quinn-udp",
  "rustc-hash",
  "rustls",
- "socket2 0.6.0",
+ "socket2",
  "thiserror 2.0.20",
  "tokio",
  "tracing",
@@ -6447,14 +5573,16 @@ dependencies = [
 
 [[package]]
 name = "quinn-proto"
-version = "0.11.13"
+version = "0.11.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31"
+checksum = "a9746dbde176634f4f2f1faf2404e30a31b2bc1e9cafb5329c95d8177a18c9fc"
 dependencies = [
+ "aws-lc-rs",
  "bytes",
- "getrandom 0.3.4",
+ "getrandom 0.4.3",
  "lru-slab",
- "rand 0.9.5",
+ "rand 0.10.2",
+ "rand_pcg",
  "ring",
  "rustc-hash",
  "rustls",
@@ -6468,16 +5596,16 @@ dependencies = [
 
 [[package]]
 name = "quinn-udp"
-version = "0.5.14"
+version = "0.5.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd"
+checksum = "35a133f956daabe89a61a685c2649f13d82d5aa4bd5d12d1277e1072a21c0694"
 dependencies = [
  "cfg_aliases",
  "libc",
  "once_cell",
- "socket2 0.6.0",
+ "socket2",
  "tracing",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -6503,43 +5631,43 @@ checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
 
 [[package]]
 name = "rand"
-version = "0.8.8"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e058c7de0b26af77780c769414d6257830bb240f3c38477dbc2c16e5f54d6d4c"
+checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41"
 dependencies = [
- "libc",
- "rand_chacha 0.3.1",
- "rand_core 0.6.4",
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.5",
 ]
 
 [[package]]
 name = "rand"
-version = "0.9.5"
+version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41"
+checksum = "c7f5fa3a058cd35567ef9bfa5e75732bee0f9e4c55fa90477bef2dfcdbc4be80"
 dependencies = [
- "rand_chacha 0.9.0",
- "rand_core 0.9.3",
+ "chacha20",
+ "getrandom 0.4.3",
+ "rand_core 0.10.1",
 ]
 
 [[package]]
 name = "rand_chacha"
-version = "0.3.1"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
 dependencies = [
  "ppv-lite86",
- "rand_core 0.6.4",
+ "rand_core 0.9.5",
 ]
 
 [[package]]
 name = "rand_chacha"
-version = "0.9.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+checksum = "3e6af7f3e25ded52c41df4e0b1af2d047e45896c2f3281792ed68a1c243daedb"
 dependencies = [
  "ppv-lite86",
- "rand_core 0.9.3",
+ "rand_core 0.10.1",
 ]
 
 [[package]]
@@ -6548,25 +5676,40 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom 0.2.16",
+ "getrandom 0.2.17",
 ]
 
 [[package]]
 name = "rand_core"
-version = "0.9.3"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
 dependencies = [
  "getrandom 0.3.4",
 ]
 
 [[package]]
-name = "raw-cpuid"
-version = "11.6.0"
+name = "rand_core"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
+
+[[package]]
+name = "rand_pcg"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "caa0f4137e1c0a72f4c651489402276c8e8e1cf081f3b0ba156d2cbeef09e86a"
+dependencies = [
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "rand_xorshift"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "498cd0dc59d73224351ee52a95fee0f1a617a2eae0e7d9d720cc622c73a54186"
+checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a"
 dependencies = [
- "bitflags 2.9.4",
+ "rand_core 0.9.5",
 ]
 
 [[package]]
@@ -6577,9 +5720,9 @@ checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"
 
 [[package]]
 name = "rayon"
-version = "1.11.0"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
+checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
 dependencies = [
  "either",
  "rayon-core",
@@ -6602,37 +5745,17 @@ version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
 dependencies = [
- "crossbeam-deque",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "rcgen"
-version = "0.14.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8774e05a7d0de114588e6a28fe7e71694b82614ed569d86d8b389dfbc98b8ad8"
-dependencies = [
- "pem 4.0.0",
- "ring",
- "rustls-pki-types",
- "time",
- "x509-parser 0.18.1",
- "yasna",
-]
-
-[[package]]
-name = "reborrow"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03251193000f4bd3b042892be858ee50e8b3719f2b08e5833ac4353724632430"
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.17"
+version = "0.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5407465600fb0548f1442edf71dd20683c6ed326200ace4b1ef0763521bb3b77"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.13.2",
 ]
 
 [[package]]
@@ -6641,36 +5764,36 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac"
 dependencies = [
- "getrandom 0.2.16",
+ "getrandom 0.2.17",
  "libredox",
  "thiserror 2.0.20",
 ]
 
 [[package]]
 name = "ref-cast"
-version = "1.0.24"
+version = "1.0.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a0ae411dbe946a674d89546582cea4ba2bb8defac896622d6496f14c23ba5cf"
+checksum = "7e440fb4e4b4147295338efb76001ab9e4efc0e5839df2c47fc5ac2381d365c3"
 dependencies = [
  "ref-cast-impl",
 ]
 
 [[package]]
 name = "ref-cast-impl"
-version = "1.0.24"
+version = "1.0.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1165225c21bff1f3bbce98f5a1f889949bc902d3575308cc7b0de30b4f6d27c7"
+checksum = "92ecd8964f8453721699a1ed72037b0db49ce2f5a5138486ee89bed6f67cdf3a"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 3.0.5",
 ]
 
 [[package]]
 name = "regex"
-version = "1.11.2"
+version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23d7fd106d8c02486a8d64e778353d1cffe08ce79ac2e82f540c86d0facf6912"
+checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -6680,9 +5803,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.10"
+version = "0.4.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b9458fa0bfeeac22b5ca447c63aaf45f28439a709ccd244698632f9aa6394d6"
+checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -6691,103 +5814,70 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.6"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "caf4aa5b0f434c91fe5c7f1ecb6a5ece2130b02ad2a590589dda5146df959001"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
 
 [[package]]
 name = "reqwest"
-version = "0.12.28"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147"
+checksum = "04e9018c9d814e5f30cc16a0f03271aeab3571e609612d9fe78c1aa8d11c2f62"
 dependencies = [
  "base64 0.22.1",
  "bytes",
- "encoding_rs",
  "futures-core",
  "futures-util",
- "h2",
- "http 1.5.0",
+ "http",
  "http-body",
  "http-body-util",
  "hyper",
  "hyper-rustls",
- "hyper-tls",
  "hyper-util",
  "js-sys",
  "log",
- "mime",
- "mime_guess",
- "native-tls",
  "percent-encoding",
  "pin-project-lite",
  "quinn",
  "rustls",
  "rustls-pki-types",
+ "rustls-platform-verifier",
  "serde",
  "serde_json",
- "serde_urlencoded",
  "sync_wrapper",
  "tokio",
- "tokio-native-tls",
  "tokio-rustls",
  "tokio-util",
  "tower",
- "tower-http 0.6.11",
+ "tower-http",
  "tower-service",
  "url",
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "wasm-streams",
  "web-sys",
- "webpki-roots 1.0.3",
+ "webpki-roots 1.0.9",
 ]
 
 [[package]]
-name = "reqwest"
-version = "0.13.1"
+name = "rfc6979"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04e9018c9d814e5f30cc16a0f03271aeab3571e609612d9fe78c1aa8d11c2f62"
+checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
 dependencies = [
- "base64 0.22.1",
- "bytes",
- "futures-channel",
- "futures-core",
- "futures-util",
- "http 1.5.0",
- "http-body",
- "http-body-util",
- "hyper",
- "hyper-rustls",
- "hyper-util",
- "js-sys",
- "log",
- "percent-encoding",
- "pin-project-lite",
- "rustls",
- "rustls-pki-types",
- "rustls-platform-verifier 0.6.1",
- "serde",
- "serde_json",
- "sync_wrapper",
- "tokio",
- "tokio-rustls",
- "tokio-util",
- "tower",
- "tower-http 0.6.11",
- "tower-service",
- "url",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-streams",
- "web-sys",
+ "hmac 0.12.1",
+ "subtle",
 ]
 
 [[package]]
-name = "resolv-conf"
-version = "0.7.4"
+name = "rfc6979"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95325155c684b1c89f7765e30bc1c42e4a6da51ca513615660cb8a62ef9a88e3"
+checksum = "b4a459cddafb3fe76b31fd8f1108007566c40301feb64dc7b54656eb7388172b"
+dependencies = [
+ "crypto-bigint 0.7.5",
+ "hmac 0.13.0",
+]
 
 [[package]]
 name = "ring"
@@ -6797,84 +5887,17 @@ checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
 dependencies = [
  "cc",
  "cfg-if",
- "getrandom 0.2.16",
+ "getrandom 0.2.17",
  "libc",
- "untrusted",
+ "untrusted 0.9.0",
  "windows-sys 0.52.0",
 ]
 
-[[package]]
-name = "ron"
-version = "0.12.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81116b9531d61eabc41aeb228e4b6b2435bcca3233b98cf3b3077d4e6e9debb3"
-dependencies = [
- "bitflags 2.9.4",
- "once_cell",
- "serde",
- "serde_derive",
- "typeid",
- "unicode-ident",
-]
-
-[[package]]
-name = "route-recognizer"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afab94fb28594581f62d981211a9a4d53cc8130bbcbbb89a0440d9b8e81a7746"
-
-[[package]]
-name = "rsa"
-version = "0.9.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78928ac1ed176a5ca1d17e578a1825f3d81ca54cf41053a592584b020cfd691b"
-dependencies = [
- "const-oid 0.9.6",
- "digest 0.10.7",
- "num-bigint-dig",
- "num-integer",
- "num-traits",
- "pkcs1",
- "pkcs8 0.10.2",
- "rand_core 0.6.4",
- "signature 2.2.0",
- "spki 0.7.3",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "rust-ini"
-version = "0.21.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "796e8d2b6696392a43bea58116b667fb4c29727dc5abd27d6acf338bb4f688c7"
-dependencies = [
- "cfg-if",
- "ordered-multimap",
-]
-
-[[package]]
-name = "rust_decimal"
-version = "1.43.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7653272e75dcac41dc199fbea6f5797633994fafd339943c06c9af16bf29cd3a"
-dependencies = [
- "arrayvec",
- "borsh",
- "bytes",
- "num-traits",
- "rand 0.8.8",
- "rand 0.9.5",
- "serde",
- "serde_json",
- "wasm-bindgen",
-]
-
 [[package]]
 name = "rustc-hash"
-version = "2.1.1"
+version = "2.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
 
 [[package]]
 name = "rustc_version"
@@ -6885,33 +5908,24 @@ dependencies = [
  "semver",
 ]
 
-[[package]]
-name = "rusticata-macros"
-version = "4.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "faf0c4a6ece9950b9abdb62b1cfcf2a68b3b67a10ba445b3bb85be2a293d0632"
-dependencies = [
- "nom",
-]
-
 [[package]]
 name = "rustix"
 version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.13.2",
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.61.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "rustls"
-version = "0.23.44"
+version = "0.23.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6725596c3f2c3a0aef021139e145d4eafe314a6623e4680ca83852b2c67ab2ba"
+checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634"
 dependencies = [
  "aws-lc-rs",
  "log",
@@ -6925,30 +5939,21 @@ dependencies = [
 
 [[package]]
 name = "rustls-native-certs"
-version = "0.8.1"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcff2dd52b58a8d98a70243663a0d234c4e2b79235637849d15913394a247d3"
+checksum = "dab5152771c58876a2146916e53e35057e1a4dfa2b9df0f0305b07f611fdea4d"
 dependencies = [
  "openssl-probe",
  "rustls-pki-types",
  "schannel",
- "security-framework 3.4.0",
-]
-
-[[package]]
-name = "rustls-pemfile"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dce314e5fee3f39953d46bb63bb8a46d40c2f8fb7cc5a3b6cab2bde9721d6e50"
-dependencies = [
- "rustls-pki-types",
+ "security-framework",
 ]
 
 [[package]]
 name = "rustls-pki-types"
-version = "1.12.0"
+version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "229a4a4c221013e7e1f1a043678c5cc39fe5171437c88fb47151a21e6f5b5c79"
+checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96"
 dependencies = [
  "web-time",
  "zeroize",
@@ -6956,44 +5961,23 @@ dependencies = [
 
 [[package]]
 name = "rustls-platform-verifier"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19787cda76408ec5404443dc8b31795c87cd8fec49762dc75fa727740d34acc1"
-dependencies = [
- "core-foundation 0.10.1",
- "core-foundation-sys",
- "jni",
- "log",
- "once_cell",
- "rustls",
- "rustls-native-certs",
- "rustls-platform-verifier-android",
- "rustls-webpki",
- "security-framework 3.4.0",
- "security-framework-sys",
- "webpki-root-certs 0.26.11",
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "rustls-platform-verifier"
-version = "0.6.1"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be59af91596cac372a6942530653ad0c3a246cdd491aaa9dcaee47f88d67d5a0"
+checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784"
 dependencies = [
- "core-foundation 0.10.1",
+ "core-foundation",
  "core-foundation-sys",
- "jni",
+ "jni 0.21.1",
  "log",
  "once_cell",
  "rustls",
  "rustls-native-certs",
  "rustls-platform-verifier-android",
  "rustls-webpki",
- "security-framework 3.4.0",
+ "security-framework",
  "security-framework-sys",
- "webpki-root-certs 1.0.2",
- "windows-sys 0.59.0",
+ "webpki-root-certs",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -7011,40 +5995,20 @@ dependencies = [
  "aws-lc-rs",
  "ring",
  "rustls-pki-types",
- "untrusted",
+ "untrusted 0.9.0",
 ]
 
 [[package]]
 name = "rustversion"
-version = "1.0.22"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
 
 [[package]]
 name = "ryu"
-version = "1.0.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
-
-[[package]]
-name = "safetensors"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "172dd94c5a87b5c79f945c863da53b2ebc7ccef4eca24ac63cca66a41aab2178"
-dependencies = [
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "salsa20"
-version = "0.11.0-rc.1"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3ff3b81c8a6e381bc1673768141383f9328048a60edddcfc752a8291a138443"
-dependencies = [
- "cfg-if",
- "cipher",
-]
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
 
 [[package]]
 name = "same-file"
@@ -7057,11 +6021,11 @@ dependencies = [
 
 [[package]]
 name = "schannel"
-version = "0.1.28"
+version = "0.1.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1"
+checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939"
 dependencies = [
- "windows-sys 0.61.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -7093,9 +6057,9 @@ dependencies = [
 
 [[package]]
 name = "schemars"
-version = "1.0.4"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82d20c4491bc164fa2f6c5d44565947a52ad80b9505d8e36f8d54c27c739fcd0"
+checksum = "687274d293b6cdc6e73e0fee520bf2049650090d7164f87672d212a3c530cf4a"
 dependencies = [
  "dyn-clone",
  "ref-cast",
@@ -7112,7 +6076,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "serde_derive_internals",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
@@ -7128,26 +6092,41 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
-name = "security-framework"
-version = "2.11.1"
+name = "sec1"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
+checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
 dependencies = [
- "bitflags 2.9.4",
- "core-foundation 0.9.4",
- "core-foundation-sys",
- "libc",
- "security-framework-sys",
+ "base16ct 0.2.0",
+ "der 0.7.10",
+ "generic-array",
+ "pkcs8 0.10.2",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "sec1"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d56d437c2f19203ce5f7122e507831de96f3d2d4d3be5af44a0b0a09d8a80e4d"
+dependencies = [
+ "base16ct 1.0.0",
+ "ctutils",
+ "der 0.8.2",
+ "hybrid-array",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
 name = "security-framework"
-version = "3.4.0"
+version = "3.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60b369d18893388b345804dc0007963c99b7d665ae71d275812d828c6f089640"
+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
 dependencies = [
- "bitflags 2.9.4",
- "core-foundation 0.10.1",
+ "bitflags 2.13.2",
+ "core-foundation",
  "core-foundation-sys",
  "libc",
  "security-framework-sys",
@@ -7155,21 +6134,27 @@ dependencies = [
 
 [[package]]
 name = "security-framework-sys"
-version = "2.15.0"
+version = "2.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc1f0cbffaac4852523ce30d8bd3c5cdc873501d96ff467ca09b6767bb8cd5c0"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
 dependencies = [
  "core-foundation-sys",
  "libc",
 ]
 
+[[package]]
+name = "seize"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b55fb86dfd3a2f5f76ea78310a88f96c4ea21a3031f8d212443d56123fd0521"
+
 [[package]]
 name = "selectors"
 version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c5d9c0c92a92d33f08817311cf3f2c29a3538a8240e94a6a3c622ce652d7e00c"
 dependencies = [
- "bitflags 2.9.4",
+ "bitflags 2.13.2",
  "cssparser",
  "derive_more",
  "log",
@@ -7182,19 +6167,14 @@ dependencies = [
  "smallvec",
 ]
 
-[[package]]
-name = "self_cell"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f7d95a54511e0c7be3f51e8867aa8cf35148d7b9445d44de2f943e2b206e749"
-
 [[package]]
 name = "semver"
-version = "1.0.26"
+version = "1.0.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56e6fa9c48d24d85fb3de5ad847117517440f6beceb7798af16b4a87d616b8d0"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
 dependencies = [
  "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -7203,12 +6183,6 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"
 
-[[package]]
-name = "seq-macro"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc"
-
 [[package]]
 name = "serde"
 version = "1.0.229"
@@ -7232,33 +6206,23 @@ dependencies = [
 ]
 
 [[package]]
-name = "serde-wasm-bindgen"
-version = "0.6.5"
+name = "serde_bencode"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8302e169f0eddcc139c70f139d19d6467353af16f9fce27e8c30158036a1e16b"
+checksum = "a70dfc7b7438b99896e7f8992363ab8e2c4ba26aa5ec675d32d1c3c2c33d413e"
 dependencies = [
- "js-sys",
  "serde",
- "wasm-bindgen",
+ "serde_bytes",
 ]
 
 [[package]]
 name = "serde_bytes"
-version = "0.11.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8437fd221bde2d4ca316d61b90e337e9e702b3820b87d63caa9ba6c02bd06d96"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "serde_cbor_2"
-version = "0.13.0"
+version = "0.11.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34aec2709de9078e077090abd848e967abab63c9fb3fdb5d4799ad359d8d482c"
+checksum = "a5d440709e79d88e51ac01c4b72fc6cb7314017bb7da9eeff678aa94c10e3ea8"
 dependencies = [
- "half",
  "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -7278,7 +6242,7 @@ checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.2",
+ "syn 3.0.5",
 ]
 
 [[package]]
@@ -7289,7 +6253,19 @@ checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "serde_ipld_dagcbor"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46182f4f08349a02b45c998ba3215d3f9de826246ba02bb9dddfe9a2a2100778"
+dependencies = [
+ "cbor4ii",
+ "ipld-core",
+ "scopeguard",
+ "serde",
 ]
 
 [[package]]
@@ -7307,23 +6283,24 @@ dependencies = [
 
 [[package]]
 name = "serde_path_to_error"
-version = "0.1.17"
+version = "0.1.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59fab13f937fa393d08645bf3a84bdfe86e296747b506ada67bb15f10f218b2a"
+checksum = "10a9ff822e371bb5403e391ecd83e182e0e77ba7f6fe0160b795797109d1b457"
 dependencies = [
  "itoa",
  "serde",
+ "serde_core",
 ]
 
 [[package]]
 name = "serde_repr"
-version = "0.1.20"
+version = "0.1.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"
+checksum = "8d3b1629de253c70a0508c3899572da79ca359fdab27c7920ff00406df418906"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 3.0.5",
 ]
 
 [[package]]
@@ -7358,17 +6335,19 @@ dependencies = [
 
 [[package]]
 name = "serde_with"
-version = "3.17.0"
+version = "3.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "381b283ce7bc6b476d903296fb59d0d36633652b633b27f64db4fb46dcbfc3b9"
+checksum = "935177bb8c0cd8ca1a4e6d1a2ac8988bea69cab4f9d3a31311e012ad27868ea4"
 dependencies = [
- "base64 0.22.1",
+ "base64 0.23.1",
+ "bs58",
  "chrono",
  "hex",
  "indexmap 1.9.3",
- "indexmap 2.12.0",
+ "indexmap 2.14.2",
+ "jiff",
  "schemars 0.9.0",
- "schemars 1.0.4",
+ "schemars 1.2.2",
  "serde_core",
  "serde_json",
  "serde_with_macros",
@@ -7377,23 +6356,23 @@ dependencies = [
 
 [[package]]
 name = "serde_with_macros"
-version = "3.17.0"
+version = "3.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6d4e30573c8cb306ed6ab1dca8423eec9a463ea0e155f45399455e0368b27e0"
+checksum = "1d607aa01a3cb0ad757d6fd216136910db3c97b102fe686585689615a02dbcdc"
 dependencies = [
- "darling 0.21.3",
+ "darling 0.24.1",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 3.0.5",
 ]
 
 [[package]]
 name = "serdect"
-version = "0.4.1"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3ef0e35b322ddfaecbc60f34ab448e157e48531288ee49fafbb053696b8ffe2"
+checksum = "66cf8fedced2fcf12406bcb34223dffb92eaf34908ede12fed414c82b7f00b3e"
 dependencies = [
- "base16ct",
+ "base16ct 1.0.0",
  "serde",
 ]
 
@@ -7416,7 +6395,7 @@ checksum = "772ee033c0916d670af7860b6e1ef7d658a4629a6d0b4c8c3e67f09b3765b75d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
@@ -7430,26 +6409,15 @@ dependencies = [
 
 [[package]]
 name = "sha1"
-version = "0.10.6"
+version = "0.10.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
+checksum = "a978451301f4db1d02937a4ab3ccce137717b81826e79b7d49ffe3244a13c3b8"
 dependencies = [
  "cfg-if",
- "cpufeatures",
+ "cpufeatures 0.2.17",
  "digest 0.10.7",
 ]
 
-[[package]]
-name = "sha1"
-version = "0.11.0-rc.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5e046edf639aa2e7afb285589e5405de2ef7e61d4b0ac1e30256e3eab911af9"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest 0.11.0-rc.3",
-]
-
 [[package]]
 name = "sha1_smol"
 version = "1.0.1"
@@ -7463,19 +6431,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
 dependencies = [
  "cfg-if",
- "cpufeatures",
+ "cpufeatures 0.2.17",
  "digest 0.10.7",
 ]
 
 [[package]]
 name = "sha2"
-version = "0.11.0-rc.2"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1e3878ab0f98e35b2df35fe53201d088299b41a6bb63e3e34dada2ac4abd924"
+checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
 dependencies = [
  "cfg-if",
- "cpufeatures",
- "digest 0.11.0-rc.3",
+ "cpufeatures 0.3.1",
+ "digest 0.11.3",
 ]
 
 [[package]]
@@ -7489,16 +6457,17 @@ dependencies = [
 
 [[package]]
 name = "shlex"
-version = "1.3.0"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "signal-hook-registry"
-version = "1.4.6"
+version = "1.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2a4719bff48cee6b39d12c020eeb490953ad2443b7055bd0b21fca26bd8c28b"
+checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
 dependencies = [
+ "errno",
  "libc",
 ]
 
@@ -7514,15 +6483,29 @@ dependencies = [
 
 [[package]]
 name = "signature"
-version = "3.0.0-rc.4"
+version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc280a6ff65c79fbd6622f64d7127f32b85563bca8c53cd2e9141d6744a9056d"
+checksum = "28d567dcbaf0049cb8ac2608a76cd95ff9e4412e1899d389ee400918ca7537f5"
+dependencies = [
+ "digest 0.11.3",
+ "rand_core 0.10.1",
+]
 
 [[package]]
 name = "simd-adler32"
-version = "0.3.7"
+version = "0.3.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea"
+
+[[package]]
+name = "simd_cesu8"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
+checksum = "11031e251abf8611c80f460e19dbdeb54a66db918e49c65a7065b46ac7aec520"
+dependencies = [
+ "rustc_version",
+ "simdutf8",
+]
 
 [[package]]
 name = "simdutf8"
@@ -7532,45 +6515,30 @@ checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
 
 [[package]]
 name = "simple-dns"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dee851d0e5e7af3721faea1843e8015e820a234f81fda3dea9247e15bac9a86a"
-dependencies = [
- "bitflags 2.9.4",
-]
-
-[[package]]
-name = "simple_asn1"
-version = "0.6.3"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "297f631f50729c8c99b84667867963997ec0b50f32b2a7dbcab828ef0541e8bb"
+checksum = "2b6f884fa9a8d48101774bfbd3aeb81e968dd22cffd19a372da69f183db22c1a"
 dependencies = [
- "num-bigint",
- "num-traits",
- "thiserror 2.0.20",
- "time",
+ "bitflags 2.13.2",
 ]
 
 [[package]]
 name = "siphasher"
-version = "1.0.1"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
+checksum = "8ee5873ec9cce0195efcb7a4e9507a04cd49aec9c83d0389df45b1ef7ba2e649"
 
 [[package]]
 name = "slab"
-version = "0.4.11"
+version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
 
 [[package]]
 name = "smallvec"
-version = "1.15.1"
+version = "1.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
-dependencies = [
- "serde",
-]
+checksum = "ba467056f1b547ed52077911161fc86985becbc60e8e1857c8a144dab0def891"
 
 [[package]]
 name = "smol_str"
@@ -7579,58 +6547,53 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fad6c857cbab2627dcf01ec85a623ca4e7dcb5691cbaa3d7fb7653671f0d09c9"
 
 [[package]]
-name = "socket2"
-version = "0.5.10"
+name = "smol_str"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
+checksum = "4aaa7368fcf4852a4c2dd92df0cace6a71f2091ca0a23391ce7f3a31833f1523"
 dependencies = [
- "libc",
- "windows-sys 0.52.0",
+ "borsh",
+ "serde_core",
 ]
 
 [[package]]
 name = "socket2"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "233504af464074f9d066d7b5416c5f9b894a5862a6506e306f7b816cdd6f1807"
-dependencies = [
- "libc",
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "socks"
-version = "0.3.4"
+version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0c3dbbd9ae980613c6dd8e28a9407b50509d3803b57624d5dfe8315218cd58b"
+checksum = "c3d1e2c7f27f8d4cb10542a02c49005dbd6e93095799d6f3be745fae9f8fedd4"
 dependencies = [
- "byteorder",
  "libc",
- "winapi",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "softbuffer"
-version = "0.4.6"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18051cdd562e792cad055119e0cdb2cfc137e44e3987532e0f9659a77931bb08"
+checksum = "aac18da81ebbf05109ab275b157c22a653bb3c12cf884450179942f81bcbf6c3"
 dependencies = [
  "bytemuck",
- "cfg_aliases",
- "core-graphics 0.24.0",
- "foreign-types 0.5.0",
  "js-sys",
- "log",
- "objc2 0.5.2",
- "objc2-foundation 0.2.2",
- "objc2-quartz-core 0.2.2",
+ "ndk",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation",
+ "objc2-quartz-core",
  "raw-window-handle",
  "redox_syscall",
+ "tracing",
  "wasm-bindgen",
  "web-sys",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "sorted-index-buffer"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea06cc588e43c632923a55450401b8f25e628131571d4e1baea1bdfdb2b5ed06"
+
 [[package]]
 name = "soup3"
 version = "0.5.0"
@@ -7665,23 +6628,23 @@ checksum = "c87e960f4dca2788eeb86bbdde8dd246be8948790b7618d656e68f9b720a86e8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
 name = "spin"
-version = "0.9.8"
+version = "0.9.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+checksum = "3763264f6b73151db08c50ff20d7d8a0b8796e021cdea7ceedad07b80155fa0e"
 dependencies = [
  "lock_api",
 ]
 
 [[package]]
 name = "spin"
-version = "0.10.0"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5fe4ccb98d9c292d56fec89a5e07da7fc4cf0dc11e156b41793132775d3e591"
+checksum = "023a211cb3138dbc438680b32560ad89f699977624c9f8dbb95a47d5b4c07dd3"
 
 [[package]]
 name = "spki"
@@ -7695,12 +6658,12 @@ dependencies = [
 
 [[package]]
 name = "spki"
-version = "0.8.0-rc.4"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8baeff88f34ed0691978ec34440140e1572b68c7dd4a495fd14a3dc1944daa80"
+checksum = "1d9efca8738c78ee9484207732f728b1ef517bbb1833d6fc0879ca898a522f6f"
 dependencies = [
  "base64ct",
- "der 0.8.0-rc.9",
+ "der 0.8.2",
 ]
 
 [[package]]
@@ -7715,234 +6678,11 @@ dependencies = [
  "unicode-segmentation",
 ]
 
-[[package]]
-name = "sqlx"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4410e73b3c0d8442c5f99b425d7a435b5ee0ae4167b3196771dd3f7a01be745f"
-dependencies = [
- "sqlx-core",
- "sqlx-macros",
- "sqlx-mysql",
- "sqlx-postgres",
- "sqlx-sqlite",
-]
-
-[[package]]
-name = "sqlx-core"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a007b6936676aa9ab40207cde35daab0a04b823be8ae004368c0793b96a61e0"
-dependencies = [
- "bytes",
- "chrono",
- "crc",
- "crossbeam-queue",
- "either",
- "event-listener",
- "futures-core",
- "futures-intrusive",
- "futures-io",
- "futures-util",
- "hashbrown 0.15.5",
- "hashlink 0.10.0",
- "indexmap 2.12.0",
- "log",
- "memchr",
- "once_cell",
- "percent-encoding",
- "rustls",
- "rustls-pemfile",
- "serde",
- "serde_json",
- "sha2 0.10.9",
- "smallvec",
- "thiserror 2.0.20",
- "tokio",
- "tokio-stream",
- "tracing",
- "url",
- "uuid",
- "webpki-roots 0.26.11",
-]
-
-[[package]]
-name = "sqlx-d1"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cdbc1b12713549997bb308b1d7b80375b5e261493fbb0d13adca78944c176de"
-dependencies = [
- "sqlx-d1-core",
-]
-
-[[package]]
-name = "sqlx-d1-core"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c616de9b85649a1f1b8e18134a29be1d201d12316d33d41605b022886b8b3817"
-dependencies = [
- "futures-core",
- "futures-util",
- "log",
- "serde",
- "sqlx-core",
- "sqlx-sqlite",
- "worker",
- "worker-sys",
-]
-
-[[package]]
-name = "sqlx-macros"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3112e2ad78643fef903618d78cf0aec1cb3134b019730edb039b69eaf531f310"
-dependencies = [
- "proc-macro2",
- "quote",
- "sqlx-core",
- "sqlx-macros-core",
- "syn 2.0.106",
-]
-
-[[package]]
-name = "sqlx-macros-core"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e9f90acc5ab146a99bf5061a7eb4976b573f560bc898ef3bf8435448dd5e7ad"
-dependencies = [
- "dotenvy",
- "either",
- "heck 0.5.0",
- "hex",
- "once_cell",
- "proc-macro2",
- "quote",
- "serde",
- "serde_json",
- "sha2 0.10.9",
- "sqlx-core",
- "sqlx-mysql",
- "sqlx-postgres",
- "sqlx-sqlite",
- "syn 2.0.106",
- "tempfile",
- "tokio",
- "url",
-]
-
-[[package]]
-name = "sqlx-mysql"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4560278f0e00ce64938540546f59f590d60beee33fffbd3b9cd47851e5fff233"
-dependencies = [
- "atoi",
- "base64 0.22.1",
- "bitflags 2.9.4",
- "byteorder",
- "bytes",
- "chrono",
- "crc",
- "digest 0.10.7",
- "dotenvy",
- "either",
- "futures-channel",
- "futures-core",
- "futures-io",
- "futures-util",
- "generic-array",
- "hex",
- "hkdf",
- "hmac",
- "itoa",
- "log",
- "md-5",
- "memchr",
- "once_cell",
- "percent-encoding",
- "rand 0.8.8",
- "rsa",
- "serde",
- "sha1 0.10.6",
- "sha2 0.10.9",
- "smallvec",
- "sqlx-core",
- "stringprep",
- "thiserror 2.0.20",
- "tracing",
- "uuid",
- "whoami",
-]
-
-[[package]]
-name = "sqlx-postgres"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5b98a57f363ed6764d5b3a12bfedf62f07aa16e1856a7ddc2a0bb190a959613"
-dependencies = [
- "atoi",
- "base64 0.22.1",
- "bitflags 2.9.4",
- "byteorder",
- "chrono",
- "crc",
- "dotenvy",
- "etcetera",
- "futures-channel",
- "futures-core",
- "futures-util",
- "hex",
- "hkdf",
- "hmac",
- "home",
- "itoa",
- "log",
- "md-5",
- "memchr",
- "once_cell",
- "rand 0.8.8",
- "serde",
- "serde_json",
- "sha2 0.10.9",
- "smallvec",
- "sqlx-core",
- "stringprep",
- "thiserror 2.0.20",
- "tracing",
- "uuid",
- "whoami",
-]
-
-[[package]]
-name = "sqlx-sqlite"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f85ca71d3a5b24e64e1d08dd8fe36c6c95c339a896cc33068148906784620540"
-dependencies = [
- "atoi",
- "chrono",
- "flume",
- "futures-channel",
- "futures-core",
- "futures-executor",
- "futures-intrusive",
- "futures-util",
- "libsqlite3-sys",
- "log",
- "percent-encoding",
- "serde",
- "serde_urlencoded",
- "sqlx-core",
- "tracing",
- "url",
- "uuid",
-]
-
 [[package]]
 name = "stable_deref_trait"
-version = "1.2.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
 [[package]]
 name = "static_assertions"
@@ -7974,17 +6714,6 @@ dependencies = [
  "quote",
 ]
 
-[[package]]
-name = "stringprep"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b4df3d392d81bd458a8a621b8bffbd2302a12ffe288a9d931670948749463b1"
-dependencies = [
- "unicode-bidi",
- "unicode-normalization",
- "unicode-properties",
-]
-
 [[package]]
 name = "strsim"
 version = "0.11.1"
@@ -7993,23 +6722,23 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "strum"
-version = "0.27.2"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
+checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd"
 dependencies = [
  "strum_macros",
 ]
 
 [[package]]
 name = "strum_macros"
-version = "0.27.2"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
+checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664"
 dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
@@ -8020,14 +6749,14 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "swarm-discovery"
-version = "0.4.0"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4eae338a4551897c6a50fa2c041c4b75f578962d9fca8adb828cf81f7158740f"
+checksum = "1b4877f20f064de34b77d79237c9caa37c393590af8ef5a2f3253d59be5a338b"
 dependencies = [
  "acto",
  "hickory-proto",
- "rand 0.9.5",
- "socket2 0.5.10",
+ "rand 0.10.2",
+ "socket2",
  "thiserror 2.0.20",
  "tokio",
  "tracing",
@@ -8035,9 +6764,9 @@ dependencies = [
 
 [[package]]
 name = "swift-rs"
-version = "1.0.7"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4057c98e2e852d51fdcfca832aac7b571f6b351ad159f9eda5db1655f8d0c4d7"
+checksum = "e45c444e496845d3f2a351146bff59aae4975b2280238df1dfaa0c7d1846f38e"
 dependencies = [
  "base64 0.21.7",
  "serde",
@@ -8056,9 +6785,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.106"
+version = "2.0.119"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ede7c438028d4436d71104916910f5bb611972c5cfd7f89b8300a8186e6fada6"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -8067,9 +6796,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "3.0.2"
+version = "3.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a207d6d6a2b7fc470b80443726053f18a2481b7e1eee970597051596567987a3"
+checksum = "12df2e0110f65b775f769bb17ef989067a1d931b2eb822bd4346631eeada89f9"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -8087,48 +6816,23 @@ dependencies = [
 
 [[package]]
 name = "synstructure"
-version = "0.13.2"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+checksum = "901704edd0dfe137f1987838ee4f259e4e063c31371bdb423f7ae38ec6f77f02"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
-]
-
-[[package]]
-name = "sysctl"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01198a2debb237c62b6826ec7081082d951f46dbb64b0e8c7649a452230d1dfc"
-dependencies = [
- "bitflags 2.9.4",
- "byteorder",
- "enum-as-inner",
- "libc",
- "thiserror 1.0.69",
- "walkdir",
-]
-
-[[package]]
-name = "system-configuration"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
-dependencies = [
- "bitflags 2.9.4",
- "core-foundation 0.9.4",
- "system-configuration-sys",
+ "syn 3.0.5",
 ]
 
 [[package]]
 name = "system-configuration"
-version = "0.7.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a13f3d0daba03132c0aa9767f98351b3488edc2c100cda2d2ec2b04f3d8d3c8b"
+checksum = "501336eb7ba9e417300a6a0fa985721065467aa83a6dcf0422a8e43e4c0328fa"
 dependencies = [
- "bitflags 2.9.4",
- "core-foundation 0.9.4",
+ "bitflags 2.13.2",
+ "core-foundation",
  "system-configuration-sys",
 ]
 
@@ -8151,42 +6855,36 @@ dependencies = [
  "cfg-expr",
  "heck 0.5.0",
  "pkg-config",
- "toml 0.8.23",
+ "toml 0.8.2",
  "version-compare",
 ]
 
-[[package]]
-name = "tagptr"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417"
-
 [[package]]
 name = "tao"
-version = "0.35.0"
+version = "0.35.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cf65722394c2ac443e80120064987f8914ee1d4e4e36e63cdf10f2990f01159"
+checksum = "d1c93047acf68669466a34690ac58cca7010bd1b201e1ec86f1fd0a75d3dd4a9"
 dependencies = [
- "bitflags 2.9.4",
- "block2 0.6.1",
- "core-foundation 0.10.1",
- "core-graphics 0.25.0",
+ "bitflags 2.13.2",
+ "block2",
+ "core-foundation",
+ "core-graphics",
  "crossbeam-channel",
  "dbus",
  "dispatch2",
- "dlopen2 0.8.0",
+ "dlopen2",
  "dpi",
  "gdkwayland-sys",
  "gdkx11-sys",
  "gtk",
- "jni",
+ "jni 0.21.1",
  "libc",
  "log",
  "ndk",
  "ndk-sys",
- "objc2 0.6.4",
+ "objc2",
  "objc2-app-kit",
- "objc2-foundation 0.3.1",
+ "objc2-foundation",
  "objc2-ui-kit",
  "once_cell",
  "parking_lot",
@@ -8203,13 +6901,13 @@ dependencies = [
 
 [[package]]
 name = "tao-macros"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4e16beb8b2ac17db28eab8bca40e62dbfbb34c0fcdc6d9826b11b7b5d047dfd"
+checksum = "5f7eeb6d99155545da6150a1795945f16ac9c178deb2a5f2e74d776107bd5849"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
@@ -8234,22 +6932,21 @@ dependencies = [
  "glob",
  "gtk",
  "heck 0.5.0",
- "http 1.5.0",
- "jni",
+ "http",
+ "jni 0.21.1",
  "libc",
  "log",
  "mime",
  "muda",
- "objc2 0.6.4",
+ "objc2",
  "objc2-app-kit",
- "objc2-foundation 0.3.1",
+ "objc2-foundation",
  "objc2-ui-kit",
  "objc2-web-kit",
  "percent-encoding",
  "plist",
  "raw-window-handle",
- "reqwest 0.13.1",
- "rustls",
+ "reqwest",
  "serde",
  "serde_json",
  "serde_repr",
@@ -8309,7 +7006,7 @@ dependencies = [
  "serde",
  "serde_json",
  "sha2 0.10.9",
- "syn 2.0.106",
+ "syn 2.0.119",
  "tauri-utils",
  "thiserror 2.0.20",
  "time",
@@ -8319,55 +7016,17 @@ dependencies = [
 ]
 
 [[package]]
-name = "tauri-macros"
-version = "2.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8b394794f399a421811d06966343e7933fcae92d59f5180b9388d1174497a45"
-dependencies = [
- "heck 0.5.0",
- "proc-macro2",
- "quote",
- "syn 2.0.106",
- "tauri-codegen",
- "tauri-utils",
-]
-
-[[package]]
-name = "tauri-plugin"
-version = "2.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8d5f58bfd0cdcfdbc0a68dc08b354eea2afc551b421de91b07b69e0dd769d57"
-dependencies = [
- "anyhow",
- "glob",
- "plist",
- "schemars 0.8.22",
- "serde",
- "serde_json",
- "tauri-utils",
- "walkdir",
-]
-
-[[package]]
-name = "tauri-plugin-opener"
-version = "2.5.5"
+name = "tauri-macros"
+version = "2.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60d60366174b745b4ef5824b8bbc1c457fd08f0ce101ff643c0a49181a9f4e91"
+checksum = "e8b394794f399a421811d06966343e7933fcae92d59f5180b9388d1174497a45"
 dependencies = [
- "dunce",
- "glob",
- "objc2-app-kit",
- "objc2-foundation 0.3.1",
- "open",
- "schemars 0.8.22",
- "serde",
- "serde_json",
- "tauri",
- "tauri-plugin",
- "thiserror 2.0.20",
- "url",
- "windows 0.61.3",
- "zbus",
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+ "tauri-codegen",
+ "tauri-utils",
 ]
 
 [[package]]
@@ -8379,9 +7038,9 @@ dependencies = [
  "cookie",
  "dpi",
  "gtk",
- "http 1.5.0",
- "jni",
- "objc2 0.6.4",
+ "http",
+ "jni 0.21.1",
+ "objc2",
  "objc2-ui-kit",
  "objc2-web-kit",
  "raw-window-handle",
@@ -8402,10 +7061,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4e6fac707727b7a2f48e4ded90976324267371073edbb415ffb73bb0458d203f"
 dependencies = [
  "gtk",
- "http 1.5.0",
- "jni",
+ "http",
+ "jni 0.21.1",
  "log",
- "objc2 0.6.4",
+ "objc2",
  "objc2-app-kit",
  "once_cell",
  "percent-encoding",
@@ -8434,7 +7093,7 @@ dependencies = [
  "dom_query",
  "dunce",
  "glob",
- "http 1.5.0",
+ "http",
  "infer",
  "json-patch",
  "log",
@@ -8452,7 +7111,7 @@ dependencies = [
  "serde_with",
  "swift-rs",
  "thiserror 2.0.20",
- "toml 0.9.12+spec-1.1.0",
+ "toml 1.1.6+spec-1.1.0",
  "url",
  "urlpattern",
  "uuid",
@@ -8461,12 +7120,13 @@ dependencies = [
 
 [[package]]
 name = "tauri-winres"
-version = "0.3.3"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd21509dd1fa9bd355dc29894a6ff10635880732396aa38c0066c1e6c1ab8074"
+checksum = "cc65d45c68858bfe420dd29e834b5d15dbecf8a07a8a16cf4d532c7b1f69d4b6"
 dependencies = [
+ "dunce",
  "embed-resource",
- "toml 0.9.12+spec-1.1.0",
+ "toml 1.1.6+spec-1.1.0",
 ]
 
 [[package]]
@@ -8479,45 +7139,25 @@ dependencies = [
  "getrandom 0.4.3",
  "once_cell",
  "rustix",
- "windows-sys 0.61.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "tendril"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4790fc369d5a530f4b544b094e31388b9b3a37c0f4652ade4505945f5660d24"
-dependencies = [
- "new_debug_unreachable",
- "utf-8",
-]
-
-[[package]]
-name = "termtree"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683"
-
-[[package]]
-name = "test-log"
-version = "0.2.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e33b98a582ea0be1168eba097538ee8dd4bbe0f2b01b22ac92ea30054e5be7b"
+checksum = "5fed54709c5b3a53d09bb1c113ea4f5ceafd1e772ddcb0030a82e1d56c087b08"
 dependencies = [
- "env_logger",
- "test-log-macros",
- "tracing-subscriber",
+ "new_debug_unreachable",
 ]
 
 [[package]]
-name = "test-log-macros"
-version = "0.2.18"
+name = "termcolor"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "451b374529930d7601b1eef8d32bc79ae870b6079b069401709c2a8bf9e75f36"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.106",
+ "winapi-util",
 ]
 
 [[package]]
@@ -8546,7 +7186,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
@@ -8557,63 +7197,63 @@ checksum = "bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.2",
+ "syn 3.0.5",
 ]
 
 [[package]]
 name = "thread_local"
-version = "1.1.9"
+version = "1.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
+checksum = "1ad99c4c6d32803332c548b1af0540b357b3f5fc0be8f6c6bfe8b2e6ae784070"
 dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "threadpool"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa"
+dependencies = [
+ "num_cpus",
+]
+
 [[package]]
 name = "time"
-version = "0.3.43"
+version = "0.3.55"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83bde6f1ec10e72d583d91623c939f623002284ef622b87de38cfd546cbf2031"
+checksum = "cdb87b95ec50ddfa440816d227a17b2ccbdda963a316a727fda0fc4334f7d134"
 dependencies = [
  "deranged",
  "js-sys",
  "num-conv",
  "powerfmt",
- "serde",
+ "serde_core",
  "time-core",
  "time-macros",
 ]
 
 [[package]]
 name = "time-core"
-version = "0.1.6"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b"
+checksum = "9e1c906769ad99c88eaa54e728060edef082f8e358ff32030cb7c7d315e81109"
 
 [[package]]
 name = "time-macros"
-version = "0.2.24"
+version = "0.2.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30cfb0125f12d9c277f35663a0a33f8c30190f4e4574868a330595412d34ebf3"
+checksum = "7e689342a48d2ea927c87ea50cabf8594854bf940e9310208848d680d668ed85"
 dependencies = [
  "num-conv",
  "time-core",
 ]
 
-[[package]]
-name = "tiny-keccak"
-version = "2.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
-dependencies = [
- "crunchy",
-]
-
 [[package]]
 name = "tinystr"
-version = "0.8.1"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b"
+checksum = "b1e27c91459209c2986af3dcf603a5a74a4368754ce37414f59acc971167f643"
 dependencies = [
  "displaydoc",
  "zerovec",
@@ -8621,24 +7261,15 @@ dependencies = [
 
 [[package]]
 name = "tinyvec"
-version = "1.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa"
-dependencies = [
- "tinyvec_macros",
-]
-
-[[package]]
-name = "tinyvec_macros"
-version = "0.1.1"
+version = "1.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+checksum = "fd3ca314f692efd6c868f8408f53fe444634a845f96c028b97d35f6a1f79f0ee"
 
 [[package]]
 name = "tokenizers"
-version = "0.21.4"
+version = "0.22.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a620b996116a59e184c2fa2dfd8251ea34a36d0a514758c6f966386bd2e03476"
+checksum = "b238e22d44a15349529690fb07bd645cf58149a1b1e44d6cb5bd1641ff1a6223"
 dependencies = [
  "ahash",
  "aho-corasick",
@@ -8647,8 +7278,6 @@ dependencies = [
  "derive_builder",
  "esaxx-rs",
  "getrandom 0.3.4",
- "hf-hub",
- "indicatif",
  "itertools",
  "log",
  "macro_rules_attribute",
@@ -8671,40 +7300,29 @@ dependencies = [
 
 [[package]]
 name = "tokio"
-version = "1.50.0"
+version = "1.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27ad5e34374e03cfffefc301becb44e9dc3c17584f414349ebe29ed26661822d"
+checksum = "202caea871b69668250d242070849eb495be178ed697a3e98aebce5bc81a0bed"
 dependencies = [
  "bytes",
  "libc",
  "mio",
- "parking_lot",
  "pin-project-lite",
  "signal-hook-registry",
- "socket2 0.6.0",
+ "socket2",
  "tokio-macros",
- "windows-sys 0.61.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "tokio-macros"
-version = "2.6.0"
+version = "2.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
+checksum = "78773a2a397f451582ce068015985c33193cf6dea8b74d2a639fe457b2f07b0e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
-]
-
-[[package]]
-name = "tokio-native-tls"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
-dependencies = [
- "native-tls",
- "tokio",
+ "syn 3.0.5",
 ]
 
 [[package]]
@@ -8719,9 +7337,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-stream"
-version = "0.1.17"
+version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047"
+checksum = "a3d06f0b082ba57c26b79407372e57cf2a1e28124f78e9479fe80322cf53420b"
 dependencies = [
  "futures-core",
  "pin-project-lite",
@@ -8730,14 +7348,19 @@ dependencies = [
 ]
 
 [[package]]
-name = "tokio-test"
-version = "0.4.5"
+name = "tokio-tungstenite"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f6d24790a10a7af737693a3e8f1d03faef7e6ca0cc99aae5066f533766de545"
+checksum = "8f72a05e828585856dacd553fba484c242c46e391fb0e58917c942ee9202915c"
 dependencies = [
- "futures-core",
+ "futures-util",
+ "log",
+ "rustls",
+ "rustls-pki-types",
  "tokio",
- "tokio-stream",
+ "tokio-rustls",
+ "tungstenite",
+ "webpki-roots 0.26.11",
 ]
 
 [[package]]
@@ -8757,53 +7380,37 @@ dependencies = [
 
 [[package]]
 name = "tokio-websockets"
-version = "0.12.1"
+version = "0.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5190767f03b86528ab9f4f6a9158072a6d0ef240d9a9591772eb411f315920f4"
+checksum = "d52efb639344a7c6adb8e62c6f3d2c19c001ff1b79a5041ba1c6ed42e19c6aa5"
 dependencies = [
  "base64 0.22.1",
  "bytes",
  "futures-core",
  "futures-sink",
- "getrandom 0.3.4",
- "http 1.5.0",
+ "getrandom 0.4.3",
+ "http",
  "httparse",
- "rand 0.9.5",
+ "rand 0.10.2",
  "ring",
  "rustls-pki-types",
+ "sha1_smol",
  "simdutf8",
  "tokio",
  "tokio-rustls",
  "tokio-util",
 ]
 
-[[package]]
-name = "tokise"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "decf97738ce15b9e9cc1671ea29b0f6c56538719e1a092d19cc2134bf144e40e"
-dependencies = [
- "futures",
- "gloo",
- "num_cpus",
- "once_cell",
- "pin-project",
- "pinned",
- "tokio",
- "tokio-stream",
- "wasm-bindgen-futures",
-]
-
 [[package]]
 name = "toml"
-version = "0.8.23"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
+checksum = "185d8ab0dfbb35cf1399a6344d8484209c088f75f8f68230da55d48d95d43e3d"
 dependencies = [
  "serde",
  "serde_spanned 0.6.9",
- "toml_datetime 0.6.11",
- "toml_edit 0.22.27",
+ "toml_datetime 0.6.3",
+ "toml_edit 0.20.2",
 ]
 
 [[package]]
@@ -8812,33 +7419,35 @@ version = "0.9.12+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863"
 dependencies = [
- "indexmap 2.12.0",
+ "indexmap 2.14.2",
  "serde_core",
  "serde_spanned 1.1.1",
  "toml_datetime 0.7.5+spec-1.1.0",
  "toml_parser",
  "toml_writer",
- "winnow 0.7.13",
+ "winnow 0.7.15",
 ]
 
 [[package]]
 name = "toml"
-version = "1.1.5+spec-1.1.0"
+version = "1.1.6+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12c0ba9680044b4ce98d391a62094047eada0d64860b80166c39f4a6b5640785"
+checksum = "920602543f0911ab71da12c50d59701da54c196d1a2bf5cb4b75667f137a406a"
 dependencies = [
+ "indexmap 2.14.2",
  "serde_core",
  "serde_spanned 1.1.1",
  "toml_datetime 1.1.1+spec-1.1.0",
  "toml_parser",
+ "toml_writer",
  "winnow 1.0.4",
 ]
 
 [[package]]
 name = "toml_datetime"
-version = "0.6.11"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c"
+checksum = "7cda73e2f1397b1262d6dfdcef8aafae14d1de7748d66822d3bfeeb6d03e5e4b"
 dependencies = [
  "serde",
 ]
@@ -8867,33 +7476,34 @@ version = "0.19.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
 dependencies = [
- "indexmap 2.12.0",
- "toml_datetime 0.6.11",
+ "indexmap 2.14.2",
+ "toml_datetime 0.6.3",
  "winnow 0.5.40",
 ]
 
 [[package]]
 name = "toml_edit"
-version = "0.20.7"
+version = "0.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70f427fce4d84c72b5b732388bf4a9f4531b53f74e2887e3ecb2481f68f66d81"
+checksum = "396e4d48bbb2b7554c944bde63101b5ae446cff6ec4a24227428f15eb72ef338"
 dependencies = [
- "indexmap 2.12.0",
- "toml_datetime 0.6.11",
+ "indexmap 2.14.2",
+ "serde",
+ "serde_spanned 0.6.9",
+ "toml_datetime 0.6.3",
  "winnow 0.5.40",
 ]
 
 [[package]]
 name = "toml_edit"
-version = "0.22.27"
+version = "0.25.15+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
+checksum = "1340ea94a5856333492c9064b02c778b191dd2c853778d9609debdcdfea3a614"
 dependencies = [
- "indexmap 2.12.0",
- "serde",
- "serde_spanned 0.6.9",
- "toml_datetime 0.6.11",
- "winnow 0.7.13",
+ "indexmap 2.14.2",
+ "toml_datetime 1.1.1+spec-1.1.0",
+ "toml_parser",
+ "winnow 1.0.4",
 ]
 
 [[package]]
@@ -8907,9 +7517,9 @@ dependencies = [
 
 [[package]]
 name = "toml_writer"
-version = "1.0.6+spec-1.1.0"
+version = "1.1.2+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab16f14aed21ee8bfd8ec22513f7287cd4a91aa92e44edfe2c17ddd004e92607"
+checksum = "7d56353a2a665ad0f41a421187180aab746c8c325620617ad883a99a1cbe66d2"
 
 [[package]]
 name = "tower"
@@ -8924,6 +7534,7 @@ dependencies = [
  "tokio",
  "tower-layer",
  "tower-service",
+ "tracing",
 ]
 
 [[package]]
@@ -8932,49 +7543,18 @@ version = "0.6.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4cfcf7e2740e6fc6d4d688b4ef00650406bb94adf4731e43c096c3a19fe40840"
 dependencies = [
- "async-compression",
- "bitflags 2.9.4",
+ "bitflags 2.13.2",
  "bytes",
- "futures-core",
  "futures-util",
- "http 1.5.0",
+ "http",
  "http-body",
- "http-body-util",
  "pin-project-lite",
- "tokio",
- "tokio-util",
  "tower",
  "tower-layer",
  "tower-service",
  "url",
 ]
 
-[[package]]
-name = "tower-http"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08a05a66a4fdd61cbbe0a1d755ffe0ca6aba159dd4820936a0ff8a8278245b9c"
-dependencies = [
- "bitflags 2.9.4",
- "bytes",
- "futures-core",
- "futures-util",
- "http 1.5.0",
- "http-body",
- "http-body-util",
- "http-range-header",
- "httpdate",
- "mime",
- "mime_guess",
- "percent-encoding",
- "pin-project-lite",
- "tokio",
- "tokio-util",
- "tower-layer",
- "tower-service",
- "tracing",
-]
-
 [[package]]
 name = "tower-layer"
 version = "0.3.3"
@@ -9007,7 +7587,7 @@ checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
@@ -9031,30 +7611,6 @@ dependencies = [
  "tracing-core",
 ]
 
-[[package]]
-name = "tracing-opentelemetry"
-version = "0.33.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adbc64cba7137545b8044cb1fe9814f7aacf3c6b5f9b45be8bb5db538befdb26"
-dependencies = [
- "js-sys",
- "opentelemetry",
- "tracing",
- "tracing-core",
- "tracing-subscriber",
- "web-time",
-]
-
-[[package]]
-name = "tracing-serde"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "704b1aeb7be0d0a84fc9828cae51dab5970fee5088f83d1dd7ee6f6246fc6ff1"
-dependencies = [
- "serde",
- "tracing-core",
-]
-
 [[package]]
 name = "tracing-subscriber"
 version = "0.3.23"
@@ -9065,117 +7621,81 @@ dependencies = [
  "nu-ansi-term",
  "once_cell",
  "regex-automata",
- "serde",
- "serde_json",
  "sharded-slab",
  "smallvec",
  "thread_local",
  "tracing",
  "tracing-core",
  "tracing-log",
- "tracing-serde",
-]
-
-[[package]]
-name = "tracing-web"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9e6a141feebd51f8d91ebfd785af50fca223c570b86852166caa3b141defe7c"
-dependencies = [
- "js-sys",
- "tracing-core",
- "tracing-subscriber",
- "wasm-bindgen",
- "web-sys",
 ]
 
 [[package]]
 name = "tray-icon"
-version = "0.24.1"
+version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65ba1e5f6b9ef9fd87e21b9c6f351554dbd717960089168fcfdef854686961dc"
+checksum = "045979e3f037cd18ad1cb2a419dfda133c5c29c9f3453370079f2255d46c257e"
 dependencies = [
  "crossbeam-channel",
  "dirs",
  "libappindicator",
  "muda",
- "objc2 0.6.4",
+ "objc2",
  "objc2-app-kit",
  "objc2-core-foundation",
  "objc2-core-graphics",
- "objc2-foundation 0.3.1",
+ "objc2-foundation",
  "once_cell",
  "png 0.18.1",
  "serde",
  "thiserror 2.0.20",
- "windows-sys 0.61.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "trunk-demo"
-version = "0.1.0"
-dependencies = [
- "console_error_panic_hook",
- "gate-chat-ui",
- "gloo-net 0.6.0",
- "serde_json",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
- "yew",
-]
+name = "try-lock"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
 [[package]]
-name = "trust-dns-proto"
-version = "0.23.2"
+name = "ts-rs"
+version = "12.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3119112651c157f4488931a01e586aa459736e9d6046d3bd9105ffb69352d374"
+checksum = "756050066659291d47a554a9f558125db17428b073c5ffce1daf5dcb0f7231d8"
 dependencies = [
- "async-trait",
- "cfg-if",
- "data-encoding",
- "enum-as-inner",
- "futures-channel",
- "futures-io",
- "futures-util",
- "idna 0.4.0",
- "ipnet",
- "once_cell",
- "rand 0.8.8",
- "smallvec",
- "thiserror 1.0.69",
- "tinyvec",
- "tokio",
- "tracing",
- "url",
+ "thiserror 2.0.20",
+ "ts-rs-macros",
 ]
 
 [[package]]
-name = "trust-dns-resolver"
-version = "0.23.2"
+name = "ts-rs-macros"
+version = "12.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10a3e6c3aff1718b3c73e395d1f35202ba2ffa847c6a62eea0db8fb4cfe30be6"
+checksum = "38d90eea51bc7988ef9e674bf80a85ba6804739e535e9cab48e4bb34a8b652aa"
 dependencies = [
- "cfg-if",
- "futures-util",
- "ipconfig",
- "lru-cache",
- "once_cell",
- "parking_lot",
- "rand 0.8.8",
- "resolv-conf",
- "smallvec",
- "thiserror 1.0.69",
- "tokio",
- "tracing",
- "trust-dns-proto",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+ "termcolor",
 ]
 
 [[package]]
-name = "try-lock"
-version = "0.2.5"
+name = "tungstenite"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
+checksum = "6c01152af293afb9c7c2a57e4b559c5620b421f6d133261c60dd2d0cdb38e6b8"
+dependencies = [
+ "bytes",
+ "data-encoding",
+ "http",
+ "httparse",
+ "log",
+ "rand 0.9.5",
+ "rustls",
+ "rustls-pki-types",
+ "sha1",
+ "thiserror 2.0.20",
+]
 
 [[package]]
 name = "typeid"
@@ -9185,26 +7705,15 @@ checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
 
 [[package]]
 name = "typenum"
-version = "1.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f"
-
-[[package]]
-name = "ucd-trie"
-version = "0.1.7"
+version = "1.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
 
 [[package]]
-name = "uds_windows"
-version = "1.1.0"
+name = "unarray"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89daebc3e6fd160ac4aa9fc8b3bf71e1f74fbf92367ae71fb83a037e8bf164b9"
-dependencies = [
- "memoffset",
- "tempfile",
- "winapi",
-]
+checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
 
 [[package]]
 name = "unic-char-property"
@@ -9247,32 +7756,11 @@ dependencies = [
  "unic-common",
 ]
 
-[[package]]
-name = "unicase"
-version = "2.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75b844d17643ee918803943289730bec8aac480150456169e647ed0b576ba539"
-
-[[package]]
-name = "unicode-bidi"
-version = "0.3.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5"
-
 [[package]]
 name = "unicode-ident"
-version = "1.0.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f63a545481291138910575129486daeaf8ac54aee4387fe7906919f7830c7d9d"
-
-[[package]]
-name = "unicode-normalization"
-version = "0.1.24"
+version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956"
-dependencies = [
- "tinyvec",
-]
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
 [[package]]
 name = "unicode-normalization-alignments"
@@ -9283,23 +7771,17 @@ dependencies = [
  "smallvec",
 ]
 
-[[package]]
-name = "unicode-properties"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e70f2a8b45122e719eb623c01822704c4e0907e7e426a05927e1a1cfff5b75d0"
-
 [[package]]
 name = "unicode-segmentation"
-version = "1.12.0"
+version = "1.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
+checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
 
 [[package]]
 name = "unicode-width"
-version = "0.2.1"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a1a07cc7db3810833284e8d372ccdc6da29741639ecc70c9ec107df0fa6154c"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
 
 [[package]]
 name = "unicode-xid"
@@ -9315,38 +7797,41 @@ checksum = "39ec24b3121d976906ece63c9daad25b85969647682eee313cb5779fdd69e14e"
 
 [[package]]
 name = "universal-hash"
-version = "0.6.0-rc.2"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a55be643b40a21558f44806b53ee9319595bc7ca6896372e4e08e5d7d83c9cd6"
+checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
 dependencies = [
- "crypto-common 0.2.0-rc.4",
+ "crypto-common 0.1.6",
  "subtle",
 ]
 
+[[package]]
+name = "universal-hash"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4987bdc12753382e0bec4a65c50738ffaabc998b9cdd1f952fb5f39b0048a96"
+dependencies = [
+ "crypto-common 0.2.2",
+ "ctutils",
+]
+
+[[package]]
+name = "unsigned-varint"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb066959b24b5196ae73cb057f45598450d2c5f71460e98c49b738086eff9c06"
+
 [[package]]
 name = "untrusted"
-version = "0.9.0"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
 
 [[package]]
-name = "ureq"
-version = "2.12.1"
+name = "untrusted"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02d1a66277ed75f640d608235660df48c8e3c19f3b4edb6a263315626cc3c01d"
-dependencies = [
- "base64 0.22.1",
- "flate2",
- "log",
- "once_cell",
- "rustls",
- "rustls-pki-types",
- "serde",
- "serde_json",
- "socks",
- "url",
- "webpki-roots 0.26.11",
-]
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
 [[package]]
 name = "url"
@@ -9355,18 +7840,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
 dependencies = [
  "form_urlencoded",
- "idna 1.1.0",
+ "idna",
  "percent-encoding",
  "serde",
  "serde_derive",
 ]
 
-[[package]]
-name = "urlencoding"
-version = "2.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
-
 [[package]]
 name = "urlpattern"
 version = "0.3.0"
@@ -9379,24 +7858,12 @@ dependencies = [
  "url",
 ]
 
-[[package]]
-name = "utf-8"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
-
 [[package]]
 name = "utf8_iter"
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 
-[[package]]
-name = "utf8parse"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
-
 [[package]]
 name = "uuid"
 version = "1.26.1"
@@ -9415,17 +7882,11 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
 
-[[package]]
-name = "vcpkg"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
-
 [[package]]
 name = "version-compare"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "852e951cb7832cb45cb1169900d19760cfa39b82bc0ea9c0e5a14ae88411c98b"
+checksum = "03c2856837ef78f57382f06b2b8563a2f512f7185d732608fd9176cb3b8edf0e"
 
 [[package]]
 name = "version_check"
@@ -9480,66 +7941,41 @@ checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 
 [[package]]
 name = "wasip2"
-version = "1.0.0+wasi-0.2.4"
+version = "1.0.4+wasi-0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03fa2761397e5bd52002cd7e73110c71af2109aca4e521a9f40473fe685b0a24"
+checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487"
 dependencies = [
  "wit-bindgen",
 ]
 
-[[package]]
-name = "wasite"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
-
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.101"
+version = "0.2.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e14915cadd45b529bb8d1f343c4ed0ac1de926144b746e2710f9cd05df6603b"
+checksum = "aecb87a33d3b0c5e3b7aa46336eaf486cffafbd281b195e4c8b80d50df2351bf"
 dependencies = [
  "cfg-if",
  "once_cell",
  "rustversion",
- "serde",
- "serde_json",
  "wasm-bindgen-macro",
  "wasm-bindgen-shared",
 ]
 
-[[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.101"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e28d1ba982ca7923fd01448d5c30c6864d0a14109560296a162f80f305fb93bb"
-dependencies = [
- "bumpalo",
- "log",
- "proc-macro2",
- "quote",
- "syn 2.0.106",
- "wasm-bindgen-shared",
-]
-
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.51"
+version = "0.4.78"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ca85039a9b469b38336411d6d6ced91f3fc87109a2a27b0c197663f5144dffe"
+checksum = "6ef4c5d3d2cdf5c54f4231181768f5510842e350db025faf1f7163b1030ed928"
 dependencies = [
- "cfg-if",
  "js-sys",
- "once_cell",
  "wasm-bindgen",
- "web-sys",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.101"
+version = "0.2.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c3d463ae3eff775b0c45df9da45d68837702ac35af998361e2c84e7c5ec1b0d"
+checksum = "a690d511e3c1a8b3a55e33511e3c2c00c78415cd23650f32b808627f5696b9ed"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -9547,61 +7983,26 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.101"
+version = "0.2.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bb4ce89b08211f923caf51d527662b75bdc9c9c7aab40f86dcb9fb85ac552aa"
+checksum = "411e4887f0071ef2d2164a9d5fdf2d20efbef78fccd3a78b0c10a1dc5295e48a"
 dependencies = [
+ "bumpalo",
  "proc-macro2",
  "quote",
- "syn 2.0.106",
- "wasm-bindgen-backend",
+ "syn 3.0.5",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.101"
+version = "0.2.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f143854a3b13752c6950862c906306adb27c7e839f7414cec8fea35beab624c1"
+checksum = "81941cd78d0c92026c33e5e01312845a4cb1e9af3407f9134b100dd03144103e"
 dependencies = [
  "unicode-ident",
 ]
 
-[[package]]
-name = "wasm-bindgen-test"
-version = "0.3.51"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80cc7f8a4114fdaa0c58383caf973fc126cf004eba25c9dc639bccd3880d55ad"
-dependencies = [
- "js-sys",
- "minicov",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-bindgen-test-macro",
-]
-
-[[package]]
-name = "wasm-bindgen-test-macro"
-version = "0.3.51"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5ada2ab788d46d4bda04c9d567702a79c8ced14f51f221646a16ed39d0e6a5d"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.106",
-]
-
-[[package]]
-name = "wasm-logger"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "074649a66bb306c8f2068c9016395fa65d8e08d2affcbf95acf3c24c3ab19718"
-dependencies = [
- "log",
- "wasm-bindgen",
- "web-sys",
-]
-
 [[package]]
 name = "wasm-streams"
 version = "0.4.2"
@@ -9617,9 +8018,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.78"
+version = "0.3.105"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77e4b637749ff0d92b8fad63aa1f7cff3cbe125fd49c175cd6345e7272638b12"
+checksum = "9fbddc4a036f00ec4f18c83445bd3115cb306a91da554919a099d9222fe4a7f8"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -9637,9 +8038,9 @@ dependencies = [
 
 [[package]]
 name = "web_atoms"
-version = "0.2.4"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7cff6eef815df1834fd250e3a2ff436044d82a9f1bc1980ca1dbdf07effc538"
+checksum = "ba8b815c1b593dc0baf78dd0f4fc8fdb2de53198fb1163738093e9a311c33fb3"
 dependencies = [
  "phf",
  "phf_codegen",
@@ -9647,74 +8048,6 @@ dependencies = [
  "string_cache_codegen",
 ]
 
-[[package]]
-name = "webauthn-attestation-ca"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6475c0bbd1a3f04afaa3e98880408c5be61680c5e6bd3c6f8c250990d5d3e18e"
-dependencies = [
- "base64urlsafedata",
- "openssl",
- "openssl-sys",
- "serde",
- "tracing",
- "uuid",
-]
-
-[[package]]
-name = "webauthn-rs"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c548915e0e92ee946bbf2aecf01ea21bef53d974b0793cc6732ba81a03fc422"
-dependencies = [
- "base64urlsafedata",
- "serde",
- "tracing",
- "url",
- "uuid",
- "webauthn-rs-core",
-]
-
-[[package]]
-name = "webauthn-rs-core"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "296d2d501feb715d80b8e186fb88bab1073bca17f460303a1013d17b673bea6a"
-dependencies = [
- "base64 0.21.7",
- "base64urlsafedata",
- "der-parser 9.0.0",
- "hex",
- "nom",
- "openssl",
- "openssl-sys",
- "rand 0.9.5",
- "rand_chacha 0.9.0",
- "serde",
- "serde_cbor_2",
- "serde_json",
- "thiserror 1.0.69",
- "tracing",
- "url",
- "uuid",
- "webauthn-attestation-ca",
- "webauthn-rs-proto",
- "x509-parser 0.16.0",
-]
-
-[[package]]
-name = "webauthn-rs-proto"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c37393beac9c1ed1ca6dbb30b1e01783fb316ab3a45d90ecd48c99052dd7ef1e"
-dependencies = [
- "base64 0.21.7",
- "base64urlsafedata",
- "serde",
- "serde_json",
- "url",
-]
-
 [[package]]
 name = "webkit2gtk"
 version = "2.0.2"
@@ -9761,18 +8094,9 @@ dependencies = [
 
 [[package]]
 name = "webpki-root-certs"
-version = "0.26.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75c7f0ef91146ebfb530314f5f1d24528d7f0767efbfd31dce919275413e393e"
-dependencies = [
- "webpki-root-certs 1.0.2",
-]
-
-[[package]]
-name = "webpki-root-certs"
-version = "1.0.2"
+version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e4ffd8df1c57e87c325000a3d6ef93db75279dc3a231125aac571650f22b12a"
+checksum = "b96554aa2acc8ccdb7e1c9a58a7a68dd5d13bccc69cd124cb09406db612a1c9b"
 dependencies = [
  "rustls-pki-types",
 ]
@@ -9783,23 +8107,23 @@ version = "0.26.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
 dependencies = [
- "webpki-roots 1.0.3",
+ "webpki-roots 1.0.9",
 ]
 
 [[package]]
 name = "webpki-roots"
-version = "1.0.3"
+version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32b130c0d2d49f8b6889abc456e795e82525204f27c42cf767cf0d7734e089b8"
+checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a"
 dependencies = [
  "rustls-pki-types",
 ]
 
 [[package]]
 name = "webview2-com"
-version = "0.38.0"
+version = "0.38.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4ba622a989277ef3886dd5afb3e280e3dd6d974b766118950a08f8f678ad6a4"
+checksum = "7130243a7a5b33c54a444e54842e6a9e133de08b5ad7b5861cd8ed9a6a5bc96a"
 dependencies = [
  "webview2-com-macros",
  "webview2-com-sys",
@@ -9811,41 +8135,31 @@ dependencies = [
 
 [[package]]
 name = "webview2-com-macros"
-version = "0.8.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d228f15bba3b9d56dde8bddbee66fa24545bd17b48d5128ccf4a8742b18e431"
+checksum = "67a921c1b6914c367b2b823cd4cde6f96beec77d30a939c8199bb377cf9b9b54"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
 name = "webview2-com-sys"
-version = "0.38.0"
+version = "0.38.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36695906a1b53a3bf5c4289621efedac12b73eeb0b89e7e1a89b517302d5d75c"
+checksum = "381336cfffd772377d291702245447a5251a2ffa5bad679c99e61bc48bacbf9c"
 dependencies = [
  "thiserror 2.0.20",
  "windows 0.61.3",
  "windows-core 0.61.2",
 ]
 
-[[package]]
-name = "whoami"
-version = "1.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d4a4db5077702ca3015d3d02d74974948aba2ad9e12ab7df718ee64ccd7e97d"
-dependencies = [
- "libredox",
- "wasite",
-]
-
 [[package]]
 name = "widestring"
-version = "1.2.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd7cf3379ca1aac9eea11fba24fd7e315d621f8dfe35c8d7d2be8b793726e07d"
+checksum = "72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471"
 
 [[package]]
 name = "winapi"
@@ -9869,7 +8183,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -9884,10 +8198,10 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9bec5a31f3f9362f2258fd0e9c9dd61a9ca432e7306cc78c444258f0dce9a9c"
 dependencies = [
- "objc2 0.6.4",
+ "objc2",
  "objc2-app-kit",
  "objc2-core-foundation",
- "objc2-foundation 0.3.1",
+ "objc2-foundation",
  "raw-window-handle",
  "windows-sys 0.59.0",
  "windows-version",
@@ -9992,7 +8306,7 @@ checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
@@ -10003,7 +8317,7 @@ checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
@@ -10040,13 +8354,13 @@ dependencies = [
 
 [[package]]
 name = "windows-registry"
-version = "0.5.3"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b8a9ed28765efc97bbc954883f4e6796c33a06546ebafacbabee9696967499e"
+checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"
 dependencies = [
- "windows-link 0.1.3",
- "windows-result 0.3.4",
- "windows-strings 0.4.2",
+ "windows-link 0.2.1",
+ "windows-result 0.4.1",
+ "windows-strings 0.5.1",
 ]
 
 [[package]]
@@ -10094,15 +8408,6 @@ dependencies = [
  "windows-targets 0.42.2",
 ]
 
-[[package]]
-name = "windows-sys"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
-dependencies = [
- "windows-targets 0.48.5",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
@@ -10123,18 +8428,9 @@ dependencies = [
 
 [[package]]
 name = "windows-sys"
-version = "0.60.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
-dependencies = [
- "windows-targets 0.53.3",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.61.0"
+version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e201184e40b2ede64bc2ea34968b28e33622acdbbf37104f0e4a33f7abe657aa"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
 dependencies = [
  "windows-link 0.2.1",
 ]
@@ -10154,21 +8450,6 @@ dependencies = [
  "windows_x86_64_msvc 0.42.2",
 ]
 
-[[package]]
-name = "windows-targets"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
-dependencies = [
- "windows_aarch64_gnullvm 0.48.5",
- "windows_aarch64_msvc 0.48.5",
- "windows_i686_gnu 0.48.5",
- "windows_i686_msvc 0.48.5",
- "windows_x86_64_gnu 0.48.5",
- "windows_x86_64_gnullvm 0.48.5",
- "windows_x86_64_msvc 0.48.5",
-]
-
 [[package]]
 name = "windows-targets"
 version = "0.52.6"
@@ -10178,30 +8459,13 @@ dependencies = [
  "windows_aarch64_gnullvm 0.52.6",
  "windows_aarch64_msvc 0.52.6",
  "windows_i686_gnu 0.52.6",
- "windows_i686_gnullvm 0.52.6",
+ "windows_i686_gnullvm",
  "windows_i686_msvc 0.52.6",
  "windows_x86_64_gnu 0.52.6",
  "windows_x86_64_gnullvm 0.52.6",
  "windows_x86_64_msvc 0.52.6",
 ]
 
-[[package]]
-name = "windows-targets"
-version = "0.53.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5fe6031c4041849d7c496a8ded650796e7b6ecc19df1a431c1a363342e5dc91"
-dependencies = [
- "windows-link 0.1.3",
- "windows_aarch64_gnullvm 0.53.0",
- "windows_aarch64_msvc 0.53.0",
- "windows_i686_gnu 0.53.0",
- "windows_i686_gnullvm 0.53.0",
- "windows_i686_msvc 0.53.0",
- "windows_x86_64_gnu 0.53.0",
- "windows_x86_64_gnullvm 0.53.0",
- "windows_x86_64_msvc 0.53.0",
-]
-
 [[package]]
 name = "windows-threading"
 version = "0.1.0"
@@ -10222,9 +8486,9 @@ dependencies = [
 
 [[package]]
 name = "windows-version"
-version = "0.1.5"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69e061eb0a22b4a1d778ad70f7575ec7845490abb35b08fa320df7895882cacb"
+checksum = "e4060a1da109b9d0326b7262c8e12c84df67cc0dbc9e33cf49e01ccc2eb63631"
 dependencies = [
  "windows-link 0.2.1",
 ]
@@ -10235,132 +8499,66 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
 
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
-
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
-
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
 
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
-
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
-
 [[package]]
 name = "windows_i686_gnu"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
 
-[[package]]
-name = "windows_i686_gnu"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
-
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
-[[package]]
-name = "windows_i686_gnu"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
-
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
-
 [[package]]
 name = "windows_i686_msvc"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
 
-[[package]]
-name = "windows_i686_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
-
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
-[[package]]
-name = "windows_i686_msvc"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
-
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
 
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
-
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
-
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.42.2"
@@ -10369,21 +8567,9 @@ checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.53.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
 [[package]]
 name = "windows_x86_64_msvc"
@@ -10391,24 +8577,12 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
 
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
-
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
-
 [[package]]
 name = "winnow"
 version = "0.5.40"
@@ -10420,12 +8594,9 @@ dependencies = [
 
 [[package]]
 name = "winnow"
-version = "0.7.13"
+version = "0.7.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
-dependencies = [
- "memchr",
-]
+checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
 
 [[package]]
 name = "winnow"
@@ -10436,16 +8607,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "winreg"
-version = "0.50.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1"
-dependencies = [
- "cfg-if",
- "windows-sys 0.48.0",
-]
-
 [[package]]
 name = "winreg"
 version = "0.55.0"
@@ -10456,138 +8617,53 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
-[[package]]
-name = "wiremock"
-version = "0.6.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08db1edfb05d9b3c1542e521aea074442088292f00b5f28e435c714a98f85031"
-dependencies = [
- "assert-json-diff",
- "base64 0.22.1",
- "deadpool 0.12.3",
- "futures",
- "http 1.5.0",
- "http-body-util",
- "hyper",
- "hyper-util",
- "log",
- "once_cell",
- "regex",
- "serde",
- "serde_json",
- "tokio",
- "url",
-]
-
 [[package]]
 name = "wit-bindgen"
-version = "0.45.1"
+version = "0.57.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c573471f125075647d03df72e026074b7203790d41351cd6edc96f46bcccd36"
+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
 
 [[package]]
 name = "wmi"
-version = "0.17.2"
+version = "0.18.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d3de777dce4cbcdc661d5d18e78ce4b46a37adc2bb7c0078a556c7f07bcce2f"
+checksum = "7c81b85c57a57500e56669586496bf2abd5cf082b9d32995251185d105208b64"
 dependencies = [
  "chrono",
  "futures",
  "log",
  "serde",
  "thiserror 2.0.20",
- "windows 0.61.3",
- "windows-core 0.61.2",
-]
-
-[[package]]
-name = "worker"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52e04233d0395832db635283594103c453dab95ec6e33d6897135ff7881479de"
-dependencies = [
- "async-trait",
- "bytes",
- "chrono",
- "futures-channel",
- "futures-util",
- "http 1.5.0",
- "http-body",
- "js-sys",
- "matchit 0.7.3",
- "pin-project",
- "serde",
- "serde-wasm-bindgen",
- "serde_json",
- "serde_urlencoded",
- "tokio",
- "url",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-streams",
- "web-sys",
- "worker-kv",
- "worker-macros",
- "worker-sys",
-]
-
-[[package]]
-name = "worker-kv"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0d30eb90e8db0657414129624c0d12c6cb480574bc2ddd584822db196cb9a52"
-dependencies = [
- "js-sys",
- "serde",
- "serde-wasm-bindgen",
- "serde_json",
- "thiserror 2.0.20",
- "wasm-bindgen",
- "wasm-bindgen-futures",
-]
-
-[[package]]
-name = "worker-macros"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3dc794c1a9509cbf9df713944227a1097f4bd70d8fed8f4866cb1c1c81eca48d"
-dependencies = [
- "async-trait",
- "proc-macro2",
- "quote",
- "syn 2.0.106",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "wasm-bindgen-macro-support",
- "worker-sys",
+ "windows 0.62.2",
+ "windows-core 0.62.2",
 ]
 
 [[package]]
-name = "worker-sys"
-version = "0.6.1"
+name = "wnaf"
+version = "0.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "622487961193b4421cc0b1eee3a158164c958a1bd0731ff535e2c4a5dd2af30f"
+checksum = "795ca18b3fdb5e62bf982199278341ddcf7ebf7d32e25e212ad05d496e95f6fa"
 dependencies = [
- "cfg-if",
- "js-sys",
- "wasm-bindgen",
- "web-sys",
+ "ff 0.14.0",
+ "group 0.14.0",
+ "hybrid-array",
+ "primefield",
 ]
 
 [[package]]
 name = "writeable"
-version = "0.6.1"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb"
+checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
 
 [[package]]
 name = "wry"
-version = "0.55.0"
+version = "0.55.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3013fd6116aac351dd2e18f349b28b2cfef3a5ff3253a9d0ce2d7193bb1b4429"
+checksum = "186f9871daa55fd9c016578b810d149de58367113db7fb72b462d2323ce19514"
 dependencies = [
  "base64 0.22.1",
- "block2 0.6.1",
+ "block2",
  "cookie",
  "crossbeam-channel",
  "dirs",
@@ -10596,15 +8672,15 @@ dependencies = [
  "dunce",
  "gdkx11",
  "gtk",
- "http 1.5.0",
+ "http",
  "javascriptcore-rs",
- "jni",
+ "jni 0.21.1",
  "libc",
  "ndk",
- "objc2 0.6.4",
+ "objc2",
  "objc2-app-kit",
  "objc2-core-foundation",
- "objc2-foundation 0.3.1",
+ "objc2-foundation",
  "objc2-ui-kit",
  "objc2-web-kit",
  "once_cell",
@@ -10665,45 +8741,32 @@ dependencies = [
 ]
 
 [[package]]
-name = "x509-parser"
-version = "0.16.0"
+name = "x25519-dalek"
+version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcbc162f30700d6f3f82a24bf7cc62ffe7caea42c0b2cba8bf7f3ae50cf51f69"
+checksum = "e7e8131a03190127fb2263afc72b322ecadae46b6ff8c6f399ff5d02f5559af6"
 dependencies = [
- "asn1-rs 0.6.2",
- "data-encoding",
- "der-parser 9.0.0",
- "lazy_static",
- "nom",
- "oid-registry 0.7.1",
- "rusticata-macros",
- "thiserror 1.0.69",
- "time",
+ "curve25519-dalek",
+ "rand_core 0.10.1",
+ "zeroize",
 ]
 
 [[package]]
-name = "x509-parser"
-version = "0.18.1"
+name = "x509-cert"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d43b0f71ce057da06bc0851b23ee24f3f86190b07203dd8f567d0b706a185202"
+checksum = "1301e935010a701ae5f8655edc0ad17c44bad3ac5ce8c39185f75453b720ae94"
 dependencies = [
- "asn1-rs 0.7.1",
- "data-encoding",
- "der-parser 10.0.0",
- "lazy_static",
- "nom",
- "oid-registry 0.8.1",
- "ring",
- "rusticata-macros",
- "thiserror 2.0.20",
- "time",
+ "const-oid 0.9.6",
+ "der 0.7.10",
+ "spki 0.7.3",
 ]
 
 [[package]]
 name = "xml-rs"
-version = "0.8.27"
+version = "0.8.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fd8403733700263c6eb89f192880191f1b83e332f7a20371ddcf421c4a337c7"
+checksum = "e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7"
 
 [[package]]
 name = "xmltree"
@@ -10714,100 +8777,12 @@ dependencies = [
  "xml-rs",
 ]
 
-[[package]]
-name = "yaml-rust2"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b36710ce3a279cfce8465dbab826f161675a262950b922cb2c3663852dfe9eb0"
-dependencies = [
- "arraydeque",
- "encoding_rs",
- "hashlink 0.11.1",
-]
-
-[[package]]
-name = "yasna"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5f6765e852b9b4dc8e2a76843e4d64d1cea8e79bcde0b6901aea8e7c7f08282"
-dependencies = [
- "bit-vec 0.9.1",
- "time",
-]
-
-[[package]]
-name = "yew"
-version = "0.21.0"
-source = "git+https://github.com/yewstack/yew#b7a599b9e4879fce18d0a3f3cbbe7c0d526e9f2d"
-dependencies = [
- "console_error_panic_hook",
- "futures",
- "gloo",
- "implicit-clone",
- "indexmap 2.12.0",
- "js-sys",
- "rustversion",
- "serde",
- "slab",
- "thiserror 2.0.20",
- "tokio",
- "tokise",
- "tracing",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
- "yew-macro",
-]
-
-[[package]]
-name = "yew-macro"
-version = "0.21.0"
-source = "git+https://github.com/yewstack/yew#b7a599b9e4879fce18d0a3f3cbbe7c0d526e9f2d"
-dependencies = [
- "once_cell",
- "prettyplease",
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "rustversion",
- "syn 2.0.106",
-]
-
-[[package]]
-name = "yew-router"
-version = "0.18.0"
-source = "git+https://github.com/yewstack/yew#b7a599b9e4879fce18d0a3f3cbbe7c0d526e9f2d"
-dependencies = [
- "gloo",
- "js-sys",
- "route-recognizer",
- "serde",
- "serde_urlencoded",
- "tracing",
- "urlencoding",
- "wasm-bindgen",
- "web-sys",
- "yew",
- "yew-router-macro",
-]
-
-[[package]]
-name = "yew-router-macro"
-version = "0.18.0"
-source = "git+https://github.com/yewstack/yew#b7a599b9e4879fce18d0a3f3cbbe7c0d526e9f2d"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.106",
-]
-
 [[package]]
 name = "yoke"
-version = "0.8.0"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc"
+checksum = "709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5"
 dependencies = [
- "serde",
  "stable_deref_trait",
  "yoke-derive",
  "zerofrom",
@@ -10815,148 +8790,82 @@ dependencies = [
 
 [[package]]
 name = "yoke-derive"
-version = "0.8.0"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6"
+checksum = "33811428bee40dbceb6d545e95754741d17a6aef9a4849f0fd62e2ba4f412a78"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 3.0.5",
  "synstructure",
 ]
 
-[[package]]
-name = "z32"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2164e798d9e3d84ee2c91139ace54638059a3b23e361f5c11781c2c6459bde0f"
-
-[[package]]
-name = "zbus"
-version = "5.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d07e46d035fb8e375b2ce63ba4e4ff90a7f73cf2ffb0138b29e1158d2eaadf7"
-dependencies = [
- "async-broadcast",
- "async-executor",
- "async-io",
- "async-lock",
- "async-process",
- "async-recursion",
- "async-task",
- "async-trait",
- "blocking",
- "enumflags2",
- "event-listener",
- "futures-core",
- "futures-lite",
- "hex",
- "nix",
- "ordered-stream",
- "serde",
- "serde_repr",
- "tracing",
- "uds_windows",
- "windows-sys 0.60.2",
- "winnow 0.7.13",
- "zbus_macros",
- "zbus_names",
- "zvariant",
-]
-
-[[package]]
-name = "zbus_macros"
-version = "5.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57e797a9c847ed3ccc5b6254e8bcce056494b375b511b3d6edcec0aeb4defaca"
-dependencies = [
- "proc-macro-crate 3.3.0",
- "proc-macro2",
- "quote",
- "syn 2.0.106",
- "zbus_names",
- "zvariant",
- "zvariant_utils",
-]
-
-[[package]]
-name = "zbus_names"
-version = "4.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7be68e64bf6ce8db94f63e72f0c7eb9a60d733f7e0499e628dfab0f84d6bcb97"
-dependencies = [
- "serde",
- "static_assertions",
- "winnow 0.7.13",
- "zvariant",
-]
-
 [[package]]
 name = "zerocopy"
-version = "0.8.27"
+version = "0.8.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c"
+checksum = "d35102a9f36d089ccae9e4c6802bc118be4487b80aaffc0ab4e0cf5ce92d2873"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.27"
+version = "0.8.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831"
+checksum = "146c01f5ab44258da43cf276c74a2763db2ff3969c9c652c3f2de07041d0b2bc"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
 name = "zerofrom"
-version = "0.1.6"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272"
 dependencies = [
  "zerofrom-derive",
 ]
 
 [[package]]
 name = "zerofrom-derive"
-version = "0.1.6"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+checksum = "f75b4683f6c7f45248d4d64056a24298c6281e0993356d7d1b4a1a962ef10d4a"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 3.0.5",
  "synstructure",
 ]
 
 [[package]]
 name = "zeroize"
-version = "1.8.2"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
+checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e"
 dependencies = [
  "zeroize_derive",
 ]
 
 [[package]]
 name = "zeroize_derive"
-version = "1.4.2"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
+checksum = "3c50655cbb0fe3fc43170059e702f1ce5e19b84cec58dc87b037a09935c2f328"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
+ "syn 2.0.119",
 ]
 
 [[package]]
 name = "zerotrie"
-version = "0.2.2"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595"
+checksum = "4ea269c3bd32f0a32c321907a2ae912ba6f4649bb0fc764a15627e99a7095a3f"
 dependencies = [
  "displaydoc",
  "yoke",
@@ -10965,9 +8874,9 @@ dependencies = [
 
 [[package]]
 name = "zerovec"
-version = "0.11.4"
+version = "0.11.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b"
+checksum = "bb0464e17806c1d976d5cba29399c7f08e516e279e2ba493f63123b5fca67dd8"
 dependencies = [
  "yoke",
  "zerofrom",
@@ -10976,85 +8885,23 @@ dependencies = [
 
 [[package]]
 name = "zerovec-derive"
-version = "0.11.1"
+version = "0.11.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f"
+checksum = "34df6fc39dbd26ddc9c10e6a2984476e13acce22e64e4487636ef494369225da"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.106",
-]
-
-[[package]]
-name = "zmij"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f4a4e8e9dc5c62d159f04fcdbe07f4c3fb710415aab4754bf11505501e3251d"
-
-[[package]]
-name = "zstd"
-version = "0.13.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
-dependencies = [
- "zstd-safe",
-]
-
-[[package]]
-name = "zstd-safe"
-version = "7.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d"
-dependencies = [
- "zstd-sys",
-]
-
-[[package]]
-name = "zstd-sys"
-version = "2.0.16+zstd.1.5.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748"
-dependencies = [
- "cc",
- "pkg-config",
+ "syn 3.0.5",
 ]
 
 [[package]]
-name = "zvariant"
-version = "5.7.0"
+name = "zlib-rs"
+version = "0.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "999dd3be73c52b1fccd109a4a81e4fcd20fab1d3599c8121b38d04e1419498db"
-dependencies = [
- "endi",
- "enumflags2",
- "serde",
- "winnow 0.7.13",
- "zvariant_derive",
- "zvariant_utils",
-]
-
-[[package]]
-name = "zvariant_derive"
-version = "5.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6643fd0b26a46d226bd90d3f07c1b5321fe9bb7f04673cb37ac6d6883885b68e"
-dependencies = [
- "proc-macro-crate 3.3.0",
- "proc-macro2",
- "quote",
- "syn 2.0.106",
- "zvariant_utils",
-]
+checksum = "b268e58e7c693d7c271f93ffc4ba3b380412554231c85bf61ca7af91042a4112"
 
 [[package]]
-name = "zvariant_utils"
-version = "3.2.1"
+name = "zmij"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6949d142f89f6916deca2232cf26a8afacf2b9fdc35ce766105e104478be599"
-dependencies = [
- "proc-macro2",
- "quote",
- "serde",
- "syn 2.0.106",
- "winnow 0.7.13",
-]
+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
diff --git a/Cargo.toml b/Cargo.toml
index f825042d..f4a19bf2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,22 +1,7 @@
 [workspace]
 resolver = "2"
-members = [
-    "crates/chat-ui",
-    "crates/chat-ui/examples/trunk-demo",
-    "crates/core",
-    "crates/daemon",
-    "crates/fixtures",
-    "crates/frontend-common",
-    "crates/frontend-daemon",
-    "crates/frontend-relay",
-    "crates/frontend-tauri",
-    "crates/gui",
-    "crates/http",
-    "crates/p2p",
-    "crates/tlsforward",
-    "crates/sqlx",
-]
-default-members = ["crates/daemon"]
+members = ["src-tauri"]
+default-members = ["src-tauri"]
 
 [workspace.package]
 version = "0.1.0"
@@ -24,125 +9,9 @@ edition = "2024"
 authors = ["Hellas AI <team@hellas.ai>"]
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/hellas-ai/gate"
-keywords = ["ai", "gateway", "inference", "llm", "api"]
-categories = ["network-programming", "web-programming"]
-
-[workspace.dependencies]
-openssl = { version = "0.10", features = ["vendored"] }
-anyhow = "1.0"
-arc-swap = "1.7"
-async-trait = "0.1"
-
-# Web framework
-axum = { version = "0.8", default-features = false, features = ["json", "macros", "matched-path", "query", "tokio", "http1", "http2"] }
-base64 = "0.23"
-bytes = "1.11"
-chrono = { version = "0.4", features = ["serde"] }
-
-# CLI parsing
-clap = { version = "4", features = ["derive"] }
-
-# Configuration
-config = { version = "0.15", features = ["yaml", "toml"] }
-directories = "6"
-futures = "0.3"
-
-# Internal crates
-gate-core = { path = "crates/core" }
-gate-frontend-common = { path = "crates/frontend-common" }
-gate-frontend-daemon = { path = "crates/frontend-daemon" }
-gate-frontend-relay = { path = "crates/frontend-relay" }
-gate-frontend-tauri = { path = "crates/frontend-tauri" }
-gate-http = { path = "crates/http" }
-gate-p2p = { path = "crates/p2p" }
-gate-tlsforward = { path = "crates/tlsforward" }
-gate-sqlx = { path = "crates/sqlx" }
-hex = "0.4"
-http = "1.4"
-hyper = "1.10"
-hyper-util = { version = "*", default-features = false }
-iroh = { version = "0.95", default-features = false, features = ["discovery-local-network"] }
-
-# Testing
-mockall = "0.15"
-
-# Platform-specific (file watching)
-notify = "6.1"
-
-# Random
-getrandom = { version = "0.4", default-features=false, features = ["wasm_js"] }
-rand = { version = "0.9", features = ["std", "std_rng"] }
-rust_decimal = { version = "1.42", features = ["serde"] }
-
-# Serialization
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-serde_with = "3.17"
-sha2 = "0.10"
-
-# Error handling
-thiserror = "2.0"
-
-# Core async runtime
-tokio = { version = "1", default-features = false, features = ["sync", "time", "macros"] }
-tokio-util = "0.7"
-toml = "0.9"
-tower = { version = "0.5", features = ["util"] }
-tower-http = { version = "0.7", features = ["trace", "cors", "timeout"] }
-tower-service = "0.3"
-
-# Logging and tracing
-tracing = "0.1"
-tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }
-
-url = { version = "2.5", features = ["serde"] }
-
-# Frontend
-yew = { git = "https://github.com/yewstack/yew", default-features = false }
-yew-router = { git = "https://github.com/yewstack/yew", default-features = false }
-wasm-bindgen = { version = "0.2", default-features = false }
-wasm-bindgen-futures = { version = "0.4", default-features = false }
-web-sys = { version = "0.3", default-features = false }
-js-sys = { version = "0.3", default-features = false }
-gloo = { version = "0.11", default-features = false }
-gloo-timers = { version = "0.3", default-features = false }
-gloo-utils = { version = "0.2", default-features = false }
-gloo-events = { version = "0.2", default-features = false }
-gloo-net = { version = "0.6", default-features = false }
-wasm-logger = { version = "0.2", default-features = false }
-tracing-web = { version = "0.1", default-features = false }
-serde-wasm-bindgen = { version = "0.6", default-features = false }
-
-# Utilities
-uuid = { version = "1.23", features = ["v4", "serde", "js"] }
-webauthn-rs = { version = "0.5" }
-wiremock = "0.6"
-wasm-bindgen-test = { version = "0.3", default-features = false }
-console_error_panic_hook = { version = "0.1", default-features = false }
-
-[workspace.lints.rust]
-unsafe_code = "warn"
-unused_imports = "warn"
-unused_variables = "warn"
-dead_code = "warn"
-
-[workspace.lints.clippy]
-all = "warn"
-pedantic = "warn"
-nursery = "warn"
 
 [profile.release]
-lto = "fat"           # Enable full link-time optimization for maximum performance
-codegen-units = 1     # Use single codegen unit for better optimization (slower compile)
-strip = true          # Strip debug symbols for smaller binaries
-panic = "abort"       # Use abort instead of unwind for smaller binaries
-opt-level = 3         # Maximum optimization level
-overflow-checks = false  # Disable overflow checks in release for performance
-debug = false         # Ensure no debug info (strip should handle this too)
-
-# Optional: Create a profile for maximum size optimization (useful for WASM)
-[profile.release-min-size]
-inherits = "release"
-opt-level = "z"      # Optimize for size instead of speed
-lto = "fat"          # Still use LTO for size reduction
-strip = true         # Strip all symbols
+lto = "thin"
+codegen-units = 1
+strip = true
+panic = "abort"
diff --git a/Makefile b/Makefile
index 41098a9e..2d522385 100644
--- a/Makefile
+++ b/Makefile
@@ -1,270 +1,20 @@
-# Gate Project Makefile
-# Comprehensive build, test, and development commands
+.PHONY: bindings check dev ui-check ui-build
 
-# Variables
-CARGO = cargo
-TRUNK = trunk
-TAURI = cargo tauri
-RUST_LOG ?= info
-RUST_BACKTRACE ?= 1
+export CARGO_TARGET_DIR ?= /tmp/hellas-gate-target
 
-# Detect OS
-UNAME_S := $(shell uname -s)
-ifeq ($(UNAME_S),Darwin)
-    OPEN_CMD = open
-else
-    OPEN_CMD = xdg-open
-endif
+bindings:
+	cargo test --locked -p hellas-gate --lib export_bindings
 
-# Colors for output
-RED = \033[0;31m
-GREEN = \033[0;32m
-YELLOW = \033[0;33m
-BLUE = \033[0;34m
-NC = \033[0m # No Color
+check: bindings ui-build
+	cargo fmt --all -- --check
+	cargo clippy --locked --workspace --all-targets -- -D warnings
+	cargo test --locked --workspace
 
-# Default target
-.DEFAULT_GOAL := help
+ui-check:
+	tsc --noEmit -p ui/tsconfig.json
 
-# Phony targets
-.PHONY: help build dev run clean test test-unit test-integration lint fmt fmt-check check audit \
-        frontend-build-dev frontend-build frontend-clean frontend-dev \
-        frontend-daemon-dev frontend-daemon-build \
-        frontend-tauri-dev frontend-tauri-build frontend-relay-dev frontend-relay-build \
-        gui-dev gui-build gui-build-dev gui-build-dmg \
-        docs docs-deps ci pre-commit db-migrate db-reset server p2p tlsforward all-services
+dev:
+	cargo tauri dev
 
-## Help
-help: ## Show this help message
-	@echo "$(BLUE)Gate Project Makefile$(NC)"
-	@echo "$(YELLOW)Usage:$(NC) make [target]"
-	@echo ""
-	@echo "$(GREEN)Available targets:$(NC)"
-	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "  $(BLUE)%-20s$(NC) %s\n", $$1, $$2}'
-	@echo ""
-	@echo "$(YELLOW)Examples:$(NC)"
-	@echo "  make build          # Build all crates in release mode"
-	@echo "  make test           # Run all tests"
-	@echo "  make frontend-dev   # Start frontend development server"
-	@echo "  make gui-build      # Build native desktop app"
-
-## Building
-build: ## Build all crates in release mode
-	@echo "$(GREEN)Building all crates in release mode...$(NC)"
-	$(CARGO) build --release --all
-
-dev: ## Build all crates in debug mode
-	@echo "$(GREEN)Building all crates in debug mode...$(NC)"
-	$(CARGO) build --all
-
-run: ## Run the Gate server
-	@echo "$(GREEN)Starting Gate server...$(NC)"
-	RUST_LOG=$(RUST_LOG) $(CARGO) run --bin gate
-
-clean: ## Clean all build artifacts
-	@echo "$(RED)Cleaning build artifacts...$(NC)"
-	$(CARGO) clean
-	rm -rf crates/frontend-daemon/dist/*
-	rm -rf crates/frontend-tauri/dist/*
-	rm -rf crates/frontend-relay/dist/*
-	rm -f crates/frontend-daemon/assets/tailwind.output.css
-	rm -f crates/frontend-tauri/assets/tailwind.output.css
-	rm -f crates/frontend-relay/assets/tailwind.output.css
-
-## Testing & Quality
-test: ## Run all tests
-	@echo "$(GREEN)Running all tests...$(NC)"
-	$(CARGO) test --all --all-features
-
-test-unit: ## Run unit tests only
-	@echo "$(GREEN)Running unit tests...$(NC)"
-	$(CARGO) test --lib --all
-
-test-integration: ## Run integration tests only
-	@echo "$(GREEN)Running integration tests...$(NC)"
-	$(CARGO) test --test '*' --all
-
-lint: ## Run clippy on all crates
-	@echo "$(YELLOW)Running clippy...$(NC)"
-	$(CARGO) clippy --all --all-targets --all-features -- -D warnings
-
-fmt: ## Format all code with rustfmt
-	@echo "$(GREEN)Formatting code...$(NC)"
-	$(CARGO) fmt --all
-
-fmt-check: ## Check formatting without making changes
-	@echo "$(YELLOW)Checking code formatting...$(NC)"
-	$(CARGO) fmt --all -- --check
-
-check: ## Run cargo check on all crates
-	@echo "$(YELLOW)Running cargo check...$(NC)"
-	$(CARGO) check --all --all-features
-
-audit: ## Security audit of dependencies
-	@echo "$(YELLOW)Running security audit...$(NC)"
-	$(CARGO) audit
-
-
-## Frontend (alias for frontend-daemon)
-frontend-dev: frontend-daemon-dev ## Run frontend development server (alias for frontend-daemon-dev)
-
-frontend-build: frontend-daemon-build ## Build frontend for production (alias for frontend-daemon-build)
-
-frontend-build-dev: ## Build frontend for development
-	@echo "$(GREEN)Building frontend for development...$(NC)"
-	cd crates/frontend-daemon && $(TRUNK) build
-
-frontend-clean: ## Clean frontend build artifacts
-	@echo "$(RED)Cleaning frontend artifacts...$(NC)"
-	rm -rf crates/frontend-daemon/dist/*
-	rm -f crates/frontend-daemon/assets/tailwind.output.css
-
-## Frontend - Daemon
-frontend-daemon-dev: ## Run daemon frontend development server
-	@echo "$(GREEN)Starting daemon frontend dev server on http://localhost:8081...$(NC)"
-	cd crates/frontend-daemon && $(TRUNK) serve
-
-frontend-daemon-build: ## Build daemon frontend for production
-	@echo "$(GREEN)Building daemon frontend for production...$(NC)"
-	cd crates/frontend-daemon && $(TRUNK) build --release
-
-## Frontend - Tauri
-frontend-tauri-dev: ## Run Tauri frontend development server
-	@echo "$(GREEN)Starting Tauri frontend dev server on http://localhost:8081...$(NC)"
-	cd crates/frontend-tauri && $(TRUNK) serve
-
-frontend-tauri-build: ## Build Tauri frontend for production
-	@echo "$(GREEN)Building Tauri frontend for production...$(NC)"
-	cd crates/frontend-tauri && $(TRUNK) build --release
-
-## Frontend - Relay
-frontend-relay-dev: ## Run relay frontend development server
-	@echo "$(GREEN)Starting relay frontend dev server on http://localhost:8081...$(NC)"
-	cd crates/frontend-relay && $(TRUNK) serve
-
-frontend-relay-build: ## Build relay frontend for production
-	@echo "$(GREEN)Building relay frontend for production...$(NC)"
-	cd crates/frontend-relay && $(TRUNK) build --release
-
-## GUI/Tauri
-gui-dev: ## Run Tauri in development mode
-	@echo "$(GREEN)Starting Tauri development mode...$(NC)"
-	cd crates/gui && $(TAURI) dev
-
-gui-build: ## Build native desktop app
-	@echo "$(GREEN)Building native desktop app...$(NC)"
-	cd crates/gui && $(TAURI) build
-
-gui-build-dev: ## Build native desktop app in debug mode (faster)
-	@echo "$(GREEN)Building native desktop app (debug mode)...$(NC)"
-	cd crates/gui && $(TAURI) build --debug
-
-gui-build-dmg: ## Build macOS DMG installer (macOS only)
-ifeq ($(UNAME_S),Darwin)
-	@echo "$(GREEN)Building macOS DMG installer...$(NC)"
-	cd crates/gui && $(TAURI) build --bundles dmg
-else
-	@echo "$(RED)DMG building is only available on macOS$(NC)"
-	@exit 1
-endif
-
-## Documentation
-docs: ## Generate and open documentation
-	@echo "$(GREEN)Generating documentation...$(NC)"
-	$(CARGO) doc --all --no-deps --open
-
-docs-deps: ## Generate dependency graph
-	@echo "$(GREEN)Generating dependency graph...$(NC)"
-	$(CARGO) depgraph --all-deps | dot -Tpng > target/dependencies.png
-	@echo "$(GREEN)Dependency graph saved to target/dependencies.png$(NC)"
-	$(OPEN_CMD) target/dependencies.png
-
-## CI/CD
-ci: fmt-check lint test ## Run all CI checks
-	@echo "$(GREEN)All CI checks passed!$(NC)"
-
-pre-commit: fmt lint test-unit ## Run checks before committing
-	@echo "$(GREEN)Pre-commit checks passed!$(NC)"
-
-## Database
-db-migrate: ## Run database migrations
-	@echo "$(GREEN)Running database migrations...$(NC)"
-	cd crates/sqlx && sqlx migrate run
-
-db-reset: ## Reset database
-	@echo "$(RED)Resetting database...$(NC)"
-	rm -f gate.db gate.db-shm gate.db-wal
-	@echo "$(GREEN)Database reset. Run 'make db-migrate' to recreate.$(NC)"
-
-## Services
-server: ## Run the main server
-	@echo "$(GREEN)Starting Gate server...$(NC)"
-	RUST_LOG=$(RUST_LOG) $(CARGO) run --bin gate
-
-p2p: ## Run P2P service (if available)
-	@echo "$(YELLOW)P2P service is a library, not a binary. Use it as a dependency.$(NC)"
-
-tlsforward: ## Run TLS forward service
-	@echo "$(GREEN)Starting TLS forward service...$(NC)"
-	RUST_LOG=$(RUST_LOG) $(CARGO) run --bin gate-tlsforward
-
-all-services: ## Run all services (requires multiple terminals)
-	@echo "$(YELLOW)Starting all services...$(NC)"
-	@echo "$(YELLOW)This requires multiple terminal windows.$(NC)"
-	@echo ""
-	@echo "Run these commands in separate terminals:"
-	@echo "  1. make server"
-	@echo "  2. make frontend-dev"
-	@echo "  3. make tlsforward (if needed)"
-
-## Workspace Management
-workspace-check: ## Check workspace configuration
-	@echo "$(YELLOW)Checking workspace configuration...$(NC)"
-	@echo "Workspace members:"
-	@grep -A20 "members = \[" Cargo.toml | grep -E '^\s*"' | sed 's/[",]//g' | sed 's/^/  /'
-	@echo ""
-	@echo "Default members:"
-	@grep "default-members" Cargo.toml | sed 's/.*= //'
-
-## Advanced
-bench: ## Run benchmarks
-	@echo "$(GREEN)Running benchmarks...$(NC)"
-	$(CARGO) bench --all
-
-coverage: ## Generate test coverage report
-	@echo "$(GREEN)Generating test coverage...$(NC)"
-	$(CARGO) tarpaulin --all --out Html
-	$(OPEN_CMD) tarpaulin-report.html
-
-update-deps: ## Update dependencies
-	@echo "$(YELLOW)Updating dependencies...$(NC)"
-	$(CARGO) update
-	cd crates/frontend && npm update
-
-check-updates: ## Check for outdated dependencies
-	@echo "$(YELLOW)Checking for outdated dependencies...$(NC)"
-	$(CARGO) outdated
-
-## Quick Commands
-quick: dev ## Quick build for development
-	@echo "$(GREEN)Quick build complete!$(NC)"
-
-watch: ## Watch for changes and rebuild
-	@echo "$(GREEN)Watching for changes...$(NC)"
-	cargo watch -x check -x test -x run
-
-## Release
-release-patch: ## Create a patch release
-	@echo "$(YELLOW)Creating patch release...$(NC)"
-	cargo release patch
-
-release-minor: ## Create a minor release
-	@echo "$(YELLOW)Creating minor release...$(NC)"
-	cargo release minor
-
-release-major: ## Create a major release
-	@echo "$(YELLOW)Creating major release...$(NC)"
-	cargo release major
-
-docker-ci:
-	act -j gui-build -P ubuntu-latest=catthehacker/ubuntu:act-latest --matrix os:ubuntu-latest
+ui-build: ui-check
+	node ui/build.mjs
diff --git a/README.md b/README.md
index 32768aba..24aca725 100644
--- a/README.md
+++ b/README.md
@@ -1,31 +1,80 @@
-<div style="text-align: center;" align="center">
-<h1>gate</h1>
+# Hellas Gate
 
-<!-- [![Crate][crate_img]][crate_link] -->
-[![License][license_img]][license_file]
-<!-- [![Documentation][docs_img]][docs_link] -->
+Gate is the small native desktop host for Hellas. It is one Tauri process and
+one vanilla TypeScript UI. There is no companion daemon, internal HTTP control
+plane, browser-side Rust, or second implementation of the Hellas protocol.
 
-</div>
+The native process wires together the reusable pieces in `../hellas`:
 
+- a verified sealed-Fetch client with a stable caller and transport identity;
+- an Apple App Attest OpenAI Responses provider;
+- a bearer-protected `/v1/responses` gateway bound to loopback;
+- private SQLite execution history; and
+- a same-user Unix control socket carrying the existing Hellas mux and the
+  `HostControl` protobuf service.
 
-_Hellas Gate_ is a user-aligned llm inference server/proxy/router
+The only platform-specific protocol producer is the DeviceCheck bridge in
+`src-tauri/src/apple_app_attest.m`. The generic attestation boundary and the
+portable Apple verifier live in `hellas-attestation`. Provider and gateway
+runtimes live behind `hellas-sdk`; Gate contains only lifecycle and UI policy.
 
-# in-progress
-some of most of this exists, read as a wishlist rather than supported though
+The Rust/TypeScript seam is deliberately local and narrow. Rust DTOs derive
+TypeScript definitions with `ts-rs`, while `ui/src/api.ts` is the sole module
+allowed to invoke Tauri commands. The reusable non-UI seam is the `HostControl`
+protobuf service over any Hellas transport, including the local Unix transport.
+There is no npm package and no package publication in this repository.
 
-- Private local inference via built-in [`catgrad`](https://github.com/hellas-ai/catgrad) engine
-- End-to-end encrypted peer-to-peer mesh overlay to aggregate capacity across networked nodes
-- Use [LetsEncrypt](https://letsencrypt.org/) to generate a private cert for a public `https://<your-node-id>.private.hellas.ai` endpoint, Hellas will relay it over p2p
-- Upstream support for any openai/anthropic-compatible providers, openrouter, vllm, ollama etc 
-- Supports [Cursor](https://cursor.ai), [Codex](https://github.com/openai/codex) and [Claude-Code](http://rickroll.com), open-webui, charm, etc via local http server
-- API key management, cost-tracking, rate-limiting, quotas, permissions, etc
-- Smart router can optimize routing for cost, latency, etc via 'virtual models'
-- Capture/Log/Export all requests, responses, metadata through the gateway
+## Local development
 
-# future
-- Once [`catgrad`](https://github.com/hellas-ai/catgrad) ZK backend is implemented, we can support _verifying responses_- check request was serviced correctly without quantization, context injection, tampered weights, etc
-- Once [`protoproto`](https://github.com/hellas-ai/protoproto) consensus protocol is implemented, we can support settlement and thus create _decentralized_, _trustless and permissionless_ markets for llm inference
+The flake is the canonical environment. It supplies Rust, Tauri, TypeScript,
+esbuild, and Node directly; there is no npm manifest, `npm install`, or
+`node_modules` directory. Rust 1.96.1 is shared with the pinned Hellas workspace.
+Rust and frontend build output both stay under `/tmp`, off this shared checkout.
+Set `CARGO_TARGET_DIR` to override the Rust output location; the flake, Makefile,
+and CI all respect it.
 
-[license_file]: https://github.com/hellas-ai/gate/blob/master/LICENSE "Project license"
-[license_img]: https://img.shields.io/crates/l/gate.svg?style=for-the-badge "License badge"
+Gate uses local path dependencies from a sibling Hellas checkout. From a fresh
+Gate clone, prepare the exact published revision recorded in `.hellas-revision`:
 
+```sh
+git clone https://github.com/hellas-ai/hellas.git ../hellas
+git -C ../hellas checkout --detach "$(cat .hellas-revision)"
+```
+
+If `../hellas` already contains your work, keep it intact and create a separate
+parent directory with sibling `gate` and `hellas` checkouts for the pinned build.
+CI uses the same revision and layout. To update Hellas deliberately, change
+`.hellas-revision`, reconcile the desktop SDK calls, and regenerate `Cargo.lock`
+against that checkout.
+
+Then run:
+
+```sh
+nix develop
+make check
+make dev
+```
+
+`make check` runs binding generation, frontend typechecking and production
+bundling, Rust formatting, warnings-as-errors Clippy, and Rust tests with the
+checked-in lockfile. Gate's old router, daemon, relay, TLS forwarder, and
+Rust/Wasm frontend have intentionally been removed; equivalent protocol
+behavior must be added to Hellas rather than copied back into this app.
+
+## Local data and secrets
+
+Gate stores its stable identity, App Attest enrollment, assertion counters,
+provider quota/transcript state, and history below Tauri's private application
+data directory. Identity files and the Unix socket are owner-only. The OpenAI
+API key crosses the typed Tauri IPC seam once and is retained only in native
+memory for the active provider run. The loopback gateway generates a fresh
+bearer whenever it starts.
+
+## Apple App Attest
+
+The ordinary desktop build carries no restricted entitlement, so it launches
+without an Apple provisioning profile and reports App Attest as unavailable.
+An attested provider requires a separately provisioned and signed build whose
+profile matches the app bundle identifier and grants the App Attest `CDhash`
+entitlement. Gate never substitutes software assurance. See
+`docs/SIGNING.md` for the two build modes and their provisioning boundary.
diff --git a/crates/chat-ui/Cargo.toml b/crates/chat-ui/Cargo.toml
deleted file mode 100644
index be7e3b5d..00000000
--- a/crates/chat-ui/Cargo.toml
+++ /dev/null
@@ -1,49 +0,0 @@
-[package]
-name = "gate-chat-ui"
-version.workspace = true
-edition.workspace = true
-authors.workspace = true
-license.workspace = true
-
-[dependencies]
-anyhow = { workspace = true }
-base64.workspace = true
-gloo-timers = { workspace = true }
-js-sys = { workspace = true }
-# Use workspace dependencies where available
-serde = { workspace = true }
-serde_json = { workspace = true }
-
-wasm-bindgen = { workspace = true, features = ["serde-serialize"] }
-wasm-bindgen-futures = { workspace = true }
-web-sys = { workspace = true, features = [
-    "console", 
-    "HtmlElement", 
-    "Element", 
-    "DomRect", 
-    "CssStyleDeclaration", 
-    "HtmlTextAreaElement", 
-    "KeyboardEvent",
-    "File",
-    "FileList", 
-    "FileReader",
-    "HtmlInputElement",
-    "Event",
-    "ProgressEvent",
-    "Blob",
-    "HtmlSelectElement",
-    "DomTokenList"
-] }
-
-# Frontend dependencies (matching gate-frontend-daemon versions)
-yew = { workspace = true, features = ["csr"] }
-
-[dev-dependencies]
-tokio-test = "0.4"
-wasm-bindgen-test = { workspace = true }
-gloo-net = { workspace = true, features = ["http"] }
-console_error_panic_hook = { workspace = true }
-
-[[example]]
-name = "trunk-demo"
-path = "examples/trunk-demo/main.rs"
diff --git a/crates/chat-ui/README.md b/crates/chat-ui/README.md
deleted file mode 100644
index 325d3c6a..00000000
--- a/crates/chat-ui/README.md
+++ /dev/null
@@ -1,73 +0,0 @@
-# gate-chat-ui
-
-Reusable chat interface component for Yew applications. Used by gate-frontend-daemon and other frontends to provide the chat testing interface.
-
-## Responsibilities
-
-- **Chat Component**: Standalone Yew component for AI chat
-- **Message Rendering**: Markdown support with syntax highlighting
-- **Streaming Support**: Real-time token streaming display
-- **Auto-resize**: Smart textarea that grows with content
-- **Keyboard Shortcuts**: Enter to send, Shift+Enter for newline
-
-## Usage
-
-```rust
-use gate_chat_ui::ChatInterface;
-use yew::prelude::*;
-
-#[function_component(App)]
-fn app() -> Html {
-    let on_send = Callback::from(|message: String| {
-        // Handle message sending
-    });
-
-    html! {
-        <ChatInterface 
-            on_send={on_send}
-            placeholder="Type a message..."
-            initial_messages={vec![]}
-        />
-    }
-}
-```
-
-## Features
-
-- Message history with sender attribution
-- Loading states during inference
-- Error message display
-- Copy code blocks to clipboard
-- Auto-scroll to latest message
-- Mobile-responsive design
-
-## Component Props
-
-- `on_send`: Callback when user sends message
-- `placeholder`: Input field placeholder text
-- `initial_messages`: Pre-populate chat history
-- `disabled`: Disable input during processing
-
-## Dependencies
-
-Minimal WASM-compatible:
-- `yew`: Component framework
-- `web-sys`: DOM manipulation
-- `gloo-timers`: Async timeouts
-- `js-sys`: JavaScript interop
-
-## Styling
-
-Uses Tailwind CSS classes. Expects Tailwind to be available in parent application.
-
-## Browser Requirements
-
-- Modern browsers with ES2015+ support
-- ResizeObserver API for auto-resize
-- Clipboard API for copy functionality
-
-## Risks
-
-- **Parent Styling**: Requires Tailwind CSS in parent app
-- **Browser APIs**: Some features need polyfills for older browsers
-- **Memory**: Long conversations increase memory usage
\ No newline at end of file
diff --git a/crates/chat-ui/examples/trunk-demo/.cargo/config.toml b/crates/chat-ui/examples/trunk-demo/.cargo/config.toml
deleted file mode 100644
index 8afa7b6c..00000000
--- a/crates/chat-ui/examples/trunk-demo/.cargo/config.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-[target.x86_64-unknown-linux-gnu]
-linker = "clang"
-rustflags = ["-C", "link-arg=-fuse-ld=/nix/store/pqwiwgf6vsqa6gwslam239zjdsc82293-mold-2.40.1/bin/mold"]
-
-[target.aarch64-unknown-linux-gnu]
-linker = "clang"  
-rustflags = ["-C", "link-arg=-fuse-ld=/nix/store/pqwiwgf6vsqa6gwslam239zjdsc82293-mold-2.40.1/bin/mold"]
diff --git a/crates/chat-ui/examples/trunk-demo/.gitignore b/crates/chat-ui/examples/trunk-demo/.gitignore
deleted file mode 100644
index 3ce56b85..00000000
--- a/crates/chat-ui/examples/trunk-demo/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
-/dist/
-/target/
-/cassettes
-Cargo.lock
\ No newline at end of file
diff --git a/crates/chat-ui/examples/trunk-demo/Cargo.toml b/crates/chat-ui/examples/trunk-demo/Cargo.toml
deleted file mode 100644
index 24b639cb..00000000
--- a/crates/chat-ui/examples/trunk-demo/Cargo.toml
+++ /dev/null
@@ -1,19 +0,0 @@
-[package]
-name = "trunk-demo"
-version = "0.1.0"
-edition = "2021"
-
-[lib]
-crate-type = ["cdylib"]
-path = "main.rs"
-
-[dependencies]
-gate-chat-ui = { path = "../.." }
-wasm-bindgen = { workspace = true }
-web-sys = { workspace = true, features = ["Window", "Document", "Element", "HtmlElement", "DomTokenList", "HtmlSelectElement", "Request", "RequestInit", "Response"] }
-yew = { workspace = true, features = ["csr"] }
-console_error_panic_hook = { workspace = true }
-serde_json = { workspace = true }
-wasm-bindgen-futures = { workspace = true }
-gloo-net = { workspace = true, features = ["http"] }
-
diff --git a/crates/chat-ui/examples/trunk-demo/README.md b/crates/chat-ui/examples/trunk-demo/README.md
deleted file mode 100644
index 0cf7a1e4..00000000
--- a/crates/chat-ui/examples/trunk-demo/README.md
+++ /dev/null
@@ -1,30 +0,0 @@
-# Gate Chat UI Demo
-
-This demo showcases the Gate Chat UI component with support for loading real API conversation cassettes.
-
-## Running the Demo
-
-```bash
-trunk serve
-```
-
-This will start the demo app on http://localhost:8081.
-
-## Features
-
-- **Cassette Loading**: Load real API conversations from test cassettes
-- **Dark Mode**: Toggle between light and dark themes  
-- **Multimodal Support**: Send messages with images and file attachments
-- **Streaming Display**: View streaming responses from cassettes
-
-## Available Cassettes
-
-The demo includes example cassettes from:
-- OpenAI Chat Completions API (basic, streaming, multi-turn)
-- Anthropic Messages API (basic, streaming, vision)
-
-Select a cassette from the dropdown in the header to load and view the conversation.
-
-## How it Works
-
-The cassettes are symlinked from the fixtures directory and served as static files by trunk. This keeps the WASM bundle small while still providing access to all test data.
\ No newline at end of file
diff --git a/crates/chat-ui/examples/trunk-demo/Trunk.cassette.toml b/crates/chat-ui/examples/trunk-demo/Trunk.cassette.toml
deleted file mode 100644
index 888ee0f6..00000000
--- a/crates/chat-ui/examples/trunk-demo/Trunk.cassette.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-[build]
-target = "cassette.html"
-dist = "dist-cassette"
-
-[watch]
-watch = [
-  "../../src",
-  "Cargo.toml",
-  "cassette.html",
-  "cassette_demo.rs",
-  "tailwind.config.js"
-]
-
-[serve]
-port = 8081
\ No newline at end of file
diff --git a/crates/chat-ui/examples/trunk-demo/Trunk.toml b/crates/chat-ui/examples/trunk-demo/Trunk.toml
deleted file mode 100644
index f0de831b..00000000
--- a/crates/chat-ui/examples/trunk-demo/Trunk.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-[build]
-target = "index.html"
-dist = "dist"
-
-[[hooks]]
-stage = "post_build"  
-command = "sh"
-command_arguments = ["-c", "pwd && cp -rv ../../../fixtures/data/cassettes"]
-
-[serve]
-port = 8081
-open = false
-
-[watch]
-watch = ["../../src", "main.rs", "index.html"]
\ No newline at end of file
diff --git a/crates/chat-ui/examples/trunk-demo/cassette.html b/crates/chat-ui/examples/trunk-demo/cassette.html
deleted file mode 100644
index 8769bde8..00000000
--- a/crates/chat-ui/examples/trunk-demo/cassette.html
+++ /dev/null
@@ -1,14 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <title>Gate Chat UI - Cassette Demo</title>
-  <link data-trunk rel="css" href="style.css" />
-  <link data-trunk rel="rust" data-bin="cassette-demo" />
-  <link data-trunk rel="copy-file" href="tailwind.config.js" />
-</head>
-<body>
-  <div id="app"></div>
-</body>
-</html>
\ No newline at end of file
diff --git a/crates/chat-ui/examples/trunk-demo/cassette_demo.rs b/crates/chat-ui/examples/trunk-demo/cassette_demo.rs
deleted file mode 100644
index a2ce2fed..00000000
--- a/crates/chat-ui/examples/trunk-demo/cassette_demo.rs
+++ /dev/null
@@ -1,228 +0,0 @@
-use gate_chat_ui::{ChatContainer, ChatMessage, ChatResponse, Provider};
-use gate_chat_ui::utils::simple_cassette_parser::parse_cassette;
-use gate_fixtures::{list_all_cassettes, get_cassette};
-use wasm_bindgen::prelude::*;
-use web_sys::window;
-use yew::prelude::*;
-
-#[derive(Clone, PartialEq)]
-struct CassetteInfo {
-    provider: String,
-    name: String,
-    display_name: String,
-}
-
-#[function_component(App)]
-fn app() -> Html {
-    let dark_mode = use_state(|| {
-        window()
-            .and_then(|w| w.document())
-            .and_then(|d| d.document_element())
-            .map(|e| e.class_list().contains("dark"))
-            .unwrap_or(false)
-    });
-
-    let toggle_dark_mode = {
-        let dark_mode = dark_mode.clone();
-        Callback::from(move |_| {
-            let new_state = !*dark_mode;
-            dark_mode.set(new_state);
-
-            if let Some(window) = window() {
-                if let Some(document) = window.document() {
-                    if let Some(element) = document.document_element() {
-                        let class_list = element.class_list();
-                        if new_state {
-                            let _ = class_list.add_1("dark");
-                        } else {
-                            let _ = class_list.remove_1("dark");
-                        }
-                    }
-                }
-            }
-        })
-    };
-
-    // Get available cassettes
-    let available_cassettes = use_memo((), |_| {
-        let mut cassettes = Vec::new();
-        let all = list_all_cassettes();
-        
-        for (provider, names) in all {
-            for name in names {
-                let display_name = name
-                    .replace("_", " ")
-                    .split_whitespace()
-                    .map(|word| {
-                        let mut chars = word.chars();
-                        match chars.next() {
-                            None => String::new(),
-                            Some(f) => f.to_uppercase().collect::<String>() + chars.as_str(),
-                        }
-                    })
-                    .collect::<Vec<_>>()
-                    .join(" ");
-                
-                cassettes.push(CassetteInfo {
-                    provider: provider.to_string(),
-                    name: name.to_string(),
-                    display_name,
-                });
-            }
-        }
-        
-        cassettes.sort_by(|a, b| a.provider.cmp(&b.provider).then(a.name.cmp(&b.name)));
-        cassettes
-    });
-
-    let selected_cassette = use_state(|| None::<CassetteInfo>);
-    let loading_error = use_state(|| None::<String>);
-    
-    let chat_response = use_state(|| ChatResponse {
-        id: "demo-1".to_string(),
-        model: "demo-model".to_string(),
-        messages: vec![
-            ChatMessage::system("Welcome to the Gate Chat UI Cassette Demo!\\n\\nThis demo allows you to load real API conversation cassettes and view them in the chat interface. Select a cassette from the dropdown above to see a real conversation."),
-        ],
-        provider: Provider::Unknown("demo".to_string()),
-        usage: None,
-        metadata: Default::default(),
-    });
-
-    let on_cassette_select = {
-        let selected_cassette = selected_cassette.clone();
-        let chat_response = chat_response.clone();
-        let loading_error = loading_error.clone();
-        
-        Callback::from(move |e: Event| {
-            loading_error.set(None);
-            
-            let target = e.target().unwrap();
-            let select = target.dyn_into::<web_sys::HtmlSelectElement>().unwrap();
-            let value = select.value();
-            
-            if value.is_empty() {
-                selected_cassette.set(None);
-                // Reset to welcome message
-                chat_response.set(ChatResponse {
-                    id: "demo-1".to_string(),
-                    model: "demo-model".to_string(),
-                    messages: vec![
-                        ChatMessage::system("Welcome to the Gate Chat UI Cassette Demo!\\n\\nThis demo allows you to load real API conversation cassettes and view them in the chat interface. Select a cassette from the dropdown above to see a real conversation."),
-                    ],
-                    provider: Provider::Unknown("demo".to_string()),
-                    usage: None,
-                    metadata: Default::default(),
-                });
-                return;
-            }
-            
-            // Parse provider:name format
-            if let Some((provider, name)) = value.split_once(':') {
-                let cassette_info = CassetteInfo {
-                    provider: provider.to_string(),
-                    name: name.to_string(),
-                    display_name: name.replace("_", " "),
-                };
-                
-                selected_cassette.set(Some(cassette_info.clone()));
-                
-                // Load the cassette
-                if let Some(cassette_content) = get_cassette(provider, name) {
-                    match parse_cassette(cassette_content) {
-                        Ok(mut parsed_response) => {
-                            // Add a header message explaining what cassette is loaded
-                            let header = ChatMessage::system(format!(
-                                "Loaded cassette: {} - {}\\n\\nThis is a real API conversation captured for testing.",
-                                provider.to_uppercase(),
-                                cassette_info.display_name
-                            ));
-                            parsed_response.messages.insert(0, header);
-                            
-                            chat_response.set(parsed_response);
-                        }
-                        Err(e) => {
-                            loading_error.set(Some(format!("Failed to parse cassette: {}", e)));
-                        }
-                    }
-                } else {
-                    loading_error.set(Some("Failed to load cassette content".to_string()));
-                }
-            }
-        })
-    };
-
-    html! {
-        <div class="h-screen flex flex-col">
-            <div class="bg-blue-600 dark:bg-gray-800 text-white p-4 shadow-lg">
-                <div class="flex justify-between items-center mb-3">
-                    <h1 class="text-2xl font-bold">{"Gate Chat UI - Cassette Demo"}</h1>
-                    <button
-                        onclick={toggle_dark_mode}
-                        class="p-2 rounded-lg bg-white/10 hover:bg-white/20 transition-colors"
-                        title={if *dark_mode { "Switch to light mode" } else { "Switch to dark mode" }}
-                    >
-                        if *dark_mode {
-                            // Sun icon for light mode
-                            <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="w-6 h-6">
-                                <path stroke-linecap="round" stroke-linejoin="round" d="M12 3v2.25m6.364.386l-1.591 1.591M21 12h-2.25m-.386 6.364l-1.591-1.591M12 18.75V21m-4.773-4.227l-1.591 1.591M5.25 12H3m4.227-4.773L5.636 5.636M15.75 12a3.75 3.75 0 11-7.5 0 3.75 3.75 0 017.5 0z" />
-                            </svg>
-                        } else {
-                            // Moon icon for dark mode
-                            <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="w-6 h-6">
-                                <path stroke-linecap="round" stroke-linejoin="round" d="M21.752 15.002A9.718 9.718 0 0118 15.75c-5.385 0-9.75-4.365-9.75-9.75 0-1.33.266-2.597.748-3.752A9.753 9.753 0 003 11.25C3 16.635 7.365 21 12.75 21a9.753 9.753 0 009.002-5.998z" />
-                            </svg>
-                        }
-                    </button>
-                </div>
-                <div class="flex items-center gap-3">
-                    <label for="cassette-select" class="text-sm">{"Load Cassette:"}</label>
-                    <select
-                        id="cassette-select"
-                        onchange={on_cassette_select}
-                        class="flex-1 px-3 py-1.5 rounded bg-white/10 hover:bg-white/20 transition-colors cursor-pointer"
-                    >
-                        <option value="" class="bg-gray-800">{"Select a cassette..."}</option>
-                        {
-                            available_cassettes.iter().map(|cassette| {
-                                let value = format!("{}:{}", cassette.provider, cassette.name);
-                                let label = format!("{} - {}", 
-                                    cassette.provider.to_uppercase(), 
-                                    cassette.display_name
-                                );
-                                html! {
-                                    <option value={value} class="bg-gray-800">{label}</option>
-                                }
-                            }).collect::<Html>()
-                        }
-                    </select>
-                </div>
-                if let Some(error) = &*loading_error {
-                    <div class="mt-2 text-sm text-red-300">
-                        {error}
-                    </div>
-                }
-            </div>
-            <div class="flex-1 overflow-hidden">
-                <ChatContainer
-                    chat_response={(*chat_response).clone()}
-                    show_metadata={true}
-                    show_input={false}
-                    allow_images={false}
-                    allow_files={false}
-                    input_disabled={true}
-                />
-            </div>
-        </div>
-    }
-}
-
-#[wasm_bindgen(start)]
-pub fn start() {
-    console_error_panic_hook::set_once();
-    yew::Renderer::<App>::new().render();
-}
-
-fn main() {
-    // Empty main for wasm32 target
-}
\ No newline at end of file
diff --git a/crates/chat-ui/examples/trunk-demo/index.html b/crates/chat-ui/examples/trunk-demo/index.html
deleted file mode 100644
index bf2570cd..00000000
--- a/crates/chat-ui/examples/trunk-demo/index.html
+++ /dev/null
@@ -1,12 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Gate Chat UI Demo</title>
-    <link data-trunk rel="tailwind-css" href="style.css" />
-</head>
-<body class="bg-gray-50 dark:bg-gray-900 m-0">
-    <div id="app" class="h-screen"></div>
-</body>
-</html>
\ No newline at end of file
diff --git a/crates/chat-ui/examples/trunk-demo/main.rs b/crates/chat-ui/examples/trunk-demo/main.rs
deleted file mode 100644
index c70f44ea..00000000
--- a/crates/chat-ui/examples/trunk-demo/main.rs
+++ /dev/null
@@ -1,337 +0,0 @@
-use gate_chat_ui::utils::simple_cassette_parser::parse_cassette;
-use gate_chat_ui::{ChatContainer, ChatMessage, ChatResponse, MultimodalMessage, Provider};
-use gloo_net::http::Request;
-use serde_json::json;
-use wasm_bindgen::prelude::*;
-use web_sys::window;
-use yew::prelude::*;
-
-#[derive(Clone, PartialEq)]
-struct CassetteInfo {
-    provider: String,
-    name: String,
-    display_name: String,
-    path: String,
-}
-
-#[function_component(App)]
-fn app() -> Html {
-    let dark_mode = use_state(|| {
-        // Check if dark mode is already set
-        window()
-            .and_then(|w| w.document())
-            .and_then(|d| d.document_element())
-            .map(|e| e.class_list().contains("dark"))
-            .unwrap_or(false)
-    });
-
-    let toggle_dark_mode = {
-        let dark_mode = dark_mode.clone();
-        Callback::from(move |_| {
-            let new_state = !*dark_mode;
-            dark_mode.set(new_state);
-
-            // Update the document element class
-            #[allow(clippy::collapsible_if)]
-            if let Some(window) = window() {
-                if let Some(document) = window.document() {
-                    if let Some(element) = document.document_element() {
-                        let class_list = element.class_list();
-                        if new_state {
-                            let _ = class_list.add_1("dark");
-                        } else {
-                            let _ = class_list.remove_1("dark");
-                        }
-                    }
-                }
-            }
-        })
-    };
-
-    let chat_response = use_state(|| ChatResponse {
-        id: "demo-1".to_string(),
-        model: "demo-model".to_string(),
-        messages: vec![
-            ChatMessage::system("You are a helpful assistant."),
-            ChatMessage::user("Hello! Can you help me understand how this chat UI works?"),
-            ChatMessage::assistant(
-                "Of course! This is a demo of the Gate Chat UI component. It provides a clean interface for displaying chat messages between users and AI assistants. The UI supports various message types including system messages, user messages, and assistant responses.",
-            ),
-        ],
-        provider: Provider::Unknown("demo".to_string()),
-        usage: None,
-        metadata: Default::default(),
-    });
-
-    let loading_cassette = use_state(|| false);
-    let cassette_error = use_state(|| None::<String>);
-
-    // Hardcoded list of available cassettes
-    // In production, this could be fetched from an API endpoint
-    let available_cassettes = vec![
-        // OpenAI Chat Completions
-        CassetteInfo {
-            provider: "openai".to_string(),
-            name: "basic_chat_completion".to_string(),
-            display_name: "Basic Chat Completion".to_string(),
-            path: "/cassettes/openai/chat_completions/basic_chat_completion.json".to_string(),
-        },
-        CassetteInfo {
-            provider: "openai".to_string(),
-            name: "streaming_chat_completion".to_string(),
-            display_name: "Streaming Chat Completion".to_string(),
-            path: "/cassettes/openai/chat_completions/streaming_chat_completion.json".to_string(),
-        },
-        CassetteInfo {
-            provider: "openai".to_string(),
-            name: "multi_turn_conversation".to_string(),
-            display_name: "Multi-turn Conversation".to_string(),
-            path: "/cassettes/openai/chat_completions/multi_turn_conversation.json".to_string(),
-        },
-        CassetteInfo {
-            provider: "openai".to_string(),
-            name: "function_calling".to_string(),
-            display_name: "Function Calling".to_string(),
-            path: "/cassettes/openai/chat_completions/function_calling.json".to_string(),
-        },
-        CassetteInfo {
-            provider: "openai".to_string(),
-            name: "json_mode".to_string(),
-            display_name: "JSON Mode".to_string(),
-            path: "/cassettes/openai/chat_completions/json_mode.json".to_string(),
-        },
-        CassetteInfo {
-            provider: "openai".to_string(),
-            name: "system_message_instructions".to_string(),
-            display_name: "System Message Instructions".to_string(),
-            path: "/cassettes/openai/chat_completions/system_message_instructions.json".to_string(),
-        },
-        // Anthropic Messages
-        CassetteInfo {
-            provider: "anthropic".to_string(),
-            name: "basic_message".to_string(),
-            display_name: "Basic Message".to_string(),
-            path: "/cassettes/anthropic/messages/basic_message.json".to_string(),
-        },
-        CassetteInfo {
-            provider: "anthropic".to_string(),
-            name: "streaming_basic".to_string(),
-            display_name: "Streaming Basic".to_string(),
-            path: "/cassettes/anthropic/messages/streaming_basic.json".to_string(),
-        },
-        CassetteInfo {
-            provider: "anthropic".to_string(),
-            name: "vision_image_analysis".to_string(),
-            display_name: "Vision Image Analysis".to_string(),
-            path: "/cassettes/anthropic/messages/vision_image_analysis.json".to_string(),
-        },
-        CassetteInfo {
-            provider: "anthropic".to_string(),
-            name: "multi_turn_conversation".to_string(),
-            display_name: "Multi-turn Conversation".to_string(),
-            path: "/cassettes/anthropic/messages/multi_turn_conversation.json".to_string(),
-        },
-        CassetteInfo {
-            provider: "anthropic".to_string(),
-            name: "tool_use_multi_turn".to_string(),
-            display_name: "Tool Use Multi-turn".to_string(),
-            path: "/cassettes/anthropic/messages/tool_use_multi_turn.json".to_string(),
-        },
-        CassetteInfo {
-            provider: "anthropic".to_string(),
-            name: "system_prompt".to_string(),
-            display_name: "System Prompt".to_string(),
-            path: "/cassettes/anthropic/messages/system_prompt.json".to_string(),
-        },
-        // OpenAI Responses
-        CassetteInfo {
-            provider: "openai".to_string(),
-            name: "basic_response".to_string(),
-            display_name: "Basic Response".to_string(),
-            path: "/cassettes/openai/responses/basic_response.json".to_string(),
-        },
-        CassetteInfo {
-            provider: "openai".to_string(),
-            name: "basic_streaming".to_string(),
-            display_name: "Basic Streaming Response".to_string(),
-            path: "/cassettes/openai/responses/basic_streaming.json".to_string(),
-        },
-        CassetteInfo {
-            provider: "openai".to_string(),
-            name: "conversation_with_context".to_string(),
-            display_name: "Conversation with Context".to_string(),
-            path: "/cassettes/openai/responses/conversation_with_context.json".to_string(),
-        },
-    ];
-
-    let on_cassette_select = {
-        let chat_response = chat_response.clone();
-        let loading_cassette = loading_cassette.clone();
-        let cassette_error = cassette_error.clone();
-        let available_cassettes = available_cassettes.clone();
-
-        Callback::from(move |e: Event| {
-            let target = e.target().unwrap();
-            let select = target.dyn_into::<web_sys::HtmlSelectElement>().unwrap();
-            let value = select.value();
-
-            if value.is_empty() {
-                return;
-            }
-
-            // Find the selected cassette
-            let cassette = available_cassettes
-                .iter()
-                .find(|c| format!("{}:{}", c.provider, c.name) == value);
-
-            if let Some(cassette_info) = cassette {
-                loading_cassette.set(true);
-                cassette_error.set(None);
-
-                let chat_response = chat_response.clone();
-                let loading_cassette = loading_cassette.clone();
-                let cassette_error = cassette_error.clone();
-                let path = cassette_info.path.clone();
-
-                wasm_bindgen_futures::spawn_local(async move {
-                    match Request::get(&path).send().await {
-                        Ok(resp) => match resp.text().await {
-                            Ok(text) => match parse_cassette(&text) {
-                                Ok(parsed) => {
-                                    chat_response.set(parsed);
-                                }
-                                Err(e) => {
-                                    cassette_error
-                                        .set(Some(format!("Failed to parse cassette: {e}")));
-                                }
-                            },
-                            Err(e) => {
-                                cassette_error.set(Some(format!("Failed to read response: {e}")));
-                            }
-                        },
-                        Err(e) => {
-                            cassette_error.set(Some(format!("Failed to load cassette: {e}")));
-                        }
-                    }
-                    loading_cassette.set(false);
-                });
-            }
-
-            // Reset select to placeholder
-            select.set_value("");
-        })
-    };
-
-    let on_send_multimodal = {
-        let chat_response = chat_response.clone();
-        Callback::from(move |message: MultimodalMessage| {
-            let mut updated = (*chat_response).clone();
-
-            // Convert multimodal message to chat message with proper content blocks
-            let content_blocks = message.to_content_blocks();
-
-            if !content_blocks.is_empty() {
-                let user_message = ChatMessage {
-                    role: "user".to_string(),
-                    content: Some(json!(content_blocks)),
-                    tool_calls: None,
-                    name: None,
-                    metadata: Default::default(),
-                };
-                updated.messages.push(user_message);
-
-                // Simulate assistant response
-                let response_text = if message.attachments.iter().any(|a| a.is_image()) {
-                    "I can see the image(s) you've uploaded. This is a simulated response - in a real implementation, I would analyze the image content.".to_string()
-                } else if !message.attachments.is_empty() {
-                    format!(
-                        "I received {} file(s). This is a simulated response.",
-                        message.attachments.len()
-                    )
-                } else {
-                    "I received your message! This is a simulated response.".to_string()
-                };
-
-                updated.messages.push(ChatMessage::assistant(response_text));
-            }
-
-            chat_response.set(updated);
-        })
-    };
-
-    html! {
-        <div class="h-screen flex flex-col">
-            <div class="bg-blue-600 dark:bg-gray-800 text-white p-4 shadow-lg">
-                <div class="flex justify-between items-center">
-                    <h1 class="text-2xl font-bold">{"Gate Chat UI Demo"}</h1>
-                    <div class="flex items-center gap-4">
-                        <select
-                            onchange={on_cassette_select}
-                            disabled={*loading_cassette}
-                            class="px-3 py-1.5 rounded bg-white/10 hover:bg-white/20 transition-colors cursor-pointer text-sm"
-                        >
-                            <option value="" class="bg-gray-800">{"Load example..."}</option>
-                            {
-                                available_cassettes.iter().map(|cassette| {
-                                    let value = format!("{}:{}", cassette.provider, cassette.name);
-                                    let label = format!("{} - {}",
-                                        cassette.provider.to_uppercase(),
-                                        cassette.display_name
-                                    );
-                                    html! {
-                                        <option value={value} class="bg-gray-800">{label}</option>
-                                    }
-                                }).collect::<Html>()
-                            }
-                        </select>
-                        <button
-                            onclick={toggle_dark_mode}
-                            class="p-2 rounded-lg bg-white/10 hover:bg-white/20 transition-colors"
-                            title={if *dark_mode { "Switch to light mode" } else { "Switch to dark mode" }}
-                        >
-                            if *dark_mode {
-                                // Sun icon for light mode
-                                <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="w-6 h-6">
-                                    <path stroke-linecap="round" stroke-linejoin="round" d="M12 3v2.25m6.364.386l-1.591 1.591M21 12h-2.25m-.386 6.364l-1.591-1.591M12 18.75V21m-4.773-4.227l-1.591 1.591M5.25 12H3m4.227-4.773L5.636 5.636M15.75 12a3.75 3.75 0 11-7.5 0 3.75 3.75 0 017.5 0z" />
-                                </svg>
-                            } else {
-                                // Moon icon for dark mode
-                                <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="w-6 h-6">
-                                    <path stroke-linecap="round" stroke-linejoin="round" d="M21.752 15.002A9.718 9.718 0 0118 15.75c-5.385 0-9.75-4.365-9.75-9.75 0-1.33.266-2.597.748-3.752A9.753 9.753 0 003 11.25C3 16.635 7.365 21 12.75 21a9.753 9.753 0 009.002-5.998z" />
-                                </svg>
-                            }
-                        </button>
-                    </div>
-                </div>
-                if let Some(error) = &*cassette_error {
-                    <div class="mt-2 text-sm text-red-300">
-                        {error}
-                    </div>
-                }
-                if *loading_cassette {
-                    <div class="mt-2 text-sm">
-                        {"Loading cassette..."}
-                    </div>
-                }
-            </div>
-            <div class="flex-1 overflow-hidden">
-                <ChatContainer
-                    chat_response={(*chat_response).clone()}
-                    show_metadata={true}
-                    show_input={true}
-                    on_send_multimodal={Some(on_send_multimodal)}
-                    allow_images={true}
-                    allow_files={true}
-                    input_disabled={false}
-                />
-            </div>
-        </div>
-    }
-}
-
-#[wasm_bindgen(start)]
-#[allow(clippy::main_recursion)]
-pub fn main() {
-    console_error_panic_hook::set_once();
-    yew::Renderer::<App>::new().render();
-}
diff --git a/crates/chat-ui/examples/trunk-demo/style.css b/crates/chat-ui/examples/trunk-demo/style.css
deleted file mode 100644
index bd6213e1..00000000
--- a/crates/chat-ui/examples/trunk-demo/style.css
+++ /dev/null
@@ -1,3 +0,0 @@
-@tailwind base;
-@tailwind components;
-@tailwind utilities;
\ No newline at end of file
diff --git a/crates/chat-ui/examples/trunk-demo/tailwind.config.js b/crates/chat-ui/examples/trunk-demo/tailwind.config.js
deleted file mode 100644
index 9d6ac3f7..00000000
--- a/crates/chat-ui/examples/trunk-demo/tailwind.config.js
+++ /dev/null
@@ -1,29 +0,0 @@
-module.exports = {
-  darkMode: 'class',
-  content: [
-    "./index.html",
-    "./main.rs",
-    "../../src/**/*.rs",
-  ],
-  theme: {
-    extend: {
-      animation: {
-        'spin': 'spin 1s linear infinite',
-        'pulse-dot': 'pulse-dot 1.4s ease-in-out infinite',
-      },
-      keyframes: {
-        'pulse-dot': {
-          '0%, 80%, 100%': {
-            opacity: '0.3',
-            transform: 'scale(0.8)',
-          },
-          '40%': {
-            opacity: '1',
-            transform: 'scale(1)',
-          },
-        },
-      },
-    },
-  },
-  plugins: [],
-}
\ No newline at end of file
diff --git a/crates/chat-ui/src/components/chat_container.rs b/crates/chat-ui/src/components/chat_container.rs
deleted file mode 100644
index 3ac1f70e..00000000
--- a/crates/chat-ui/src/components/chat_container.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-use crate::components::{ChatInput, MessageList, StreamingIndicator};
-use crate::styles::{
-    CARD_BG, CONTAINER_BG, FLEX_BETWEEN, FLEX_CENTER_GAP_2, FLEX_COL, HEADER_PADDING,
-    PRIMARY_BORDER, ROUNDED_STANDARD, SECONDARY_TEXT, TERTIARY_TEXT, combine_styles,
-};
-use crate::types::ChatResponse;
-use crate::types::MultimodalMessage;
-use yew::prelude::*;
-
-#[derive(Properties, Clone, PartialEq)]
-pub struct ChatContainerProps {
-    pub chat_response: ChatResponse,
-    #[prop_or_default]
-    pub show_metadata: bool,
-    #[prop_or_default]
-    pub show_input: bool,
-    #[prop_or_default]
-    pub on_send_message: Option<Callback<String>>,
-    #[prop_or_default]
-    pub on_send_multimodal: Option<Callback<MultimodalMessage>>,
-    #[prop_or_default]
-    pub input_disabled: bool,
-    #[prop_or_default]
-    pub allow_images: bool,
-    #[prop_or_default]
-    pub allow_files: bool,
-    #[prop_or_default]
-    pub class: Classes,
-}
-
-#[function_component(ChatContainer)]
-pub fn chat_container(props: &ChatContainerProps) -> Html {
-    let ChatContainerProps {
-        chat_response,
-        show_metadata,
-        show_input,
-        on_send_message,
-        on_send_multimodal,
-        input_disabled,
-        allow_images,
-        allow_files,
-        class,
-    } = props;
-
-    let is_streaming = chat_response
-        .messages
-        .last()
-        .map(|m| m.is_streaming())
-        .unwrap_or(false);
-
-    html! {
-        <div class={classes!(FLEX_COL, "h-full", CONTAINER_BG, ROUNDED_STANDARD, "overflow-hidden", class.clone())}>
-            if *show_metadata {
-                <div class={combine_styles(&[CARD_BG, "border-b", PRIMARY_BORDER, HEADER_PADDING, FLEX_BETWEEN, "flex-shrink-0"])}>
-                    <div class={combine_styles(&[FLEX_CENTER_GAP_2, "gap-3"])}>
-                        <span class={combine_styles(&["font-semibold", TERTIARY_TEXT, "text-sm"])}>{format!("{:?}", chat_response.provider)}</span>
-                        <span class={combine_styles(&[SECONDARY_TEXT, "text-sm"])}>{&chat_response.model}</span>
-                    </div>
-                    if let Some(usage) = &chat_response.usage {
-                        <div class={combine_styles(&["flex gap-4 text-xs", TERTIARY_TEXT])}>
-                            if let Some(prompt) = usage.prompt_tokens {
-                                <span class="flex items-center gap-1">{format!("Prompt: {} tokens", prompt)}</span>
-                            }
-                            if let Some(completion) = usage.completion_tokens {
-                                <span class="flex items-center gap-1">{format!("Completion: {} tokens", completion)}</span>
-                            }
-                        </div>
-                    }
-                </div>
-            }
-
-            <div class="flex-1 overflow-y-auto">
-                <MessageList messages={chat_response.messages.clone()} />
-            </div>
-
-            if is_streaming {
-                <StreamingIndicator />
-            }
-
-            if *show_input {
-                if on_send_message.is_some() || on_send_multimodal.is_some() {
-                    <div class="flex-shrink-0">
-                        <ChatInput
-                            on_send={on_send_message.clone()}
-                            on_send_multimodal={on_send_multimodal.clone()}
-                            disabled={*input_disabled || is_streaming}
-                            allow_images={*allow_images}
-                            allow_files={*allow_files}
-                        />
-                    </div>
-                }
-            }
-        </div>
-    }
-}
diff --git a/crates/chat-ui/src/components/chat_input.rs b/crates/chat-ui/src/components/chat_input.rs
deleted file mode 100644
index 0bb973a1..00000000
--- a/crates/chat-ui/src/components/chat_input.rs
+++ /dev/null
@@ -1,499 +0,0 @@
-use crate::styles::{
-    CARD_BG, ERROR_TEXT, FLEX_CENTER, FLEX_COL, INPUT_COLORS, PRIMARY_BORDER, PRIMARY_TEXT,
-    STANDARD_PADDING, TRANSITION_COLORS, combine_styles,
-};
-use crate::types::{Attachment, MultimodalMessage};
-use gloo_timers::callback::Timeout;
-use wasm_bindgen::{JsCast, closure::Closure};
-use wasm_bindgen_futures::JsFuture;
-use web_sys::{
-    Event, File, FileReader, HtmlElement, HtmlInputElement, HtmlTextAreaElement, MouseEvent,
-    ProgressEvent,
-};
-use yew::prelude::*;
-
-#[derive(Properties, PartialEq)]
-pub struct ChatInputProps {
-    /// Callback for simple text messages (backward compatibility)
-    #[prop_or_default]
-    pub on_send: Option<Callback<String>>,
-    /// Callback for multimodal messages (text + attachments)
-    #[prop_or_default]
-    pub on_send_multimodal: Option<Callback<MultimodalMessage>>,
-    #[prop_or_default]
-    pub placeholder: Option<String>,
-    #[prop_or_default]
-    pub disabled: bool,
-    #[prop_or_default]
-    pub allow_images: bool,
-    #[prop_or_default]
-    pub allow_files: bool,
-    /// Maximum file size in bytes (default: 10MB)
-    #[prop_or(10 * 1024 * 1024)]
-    pub max_file_size: usize,
-}
-
-#[hook]
-fn use_auto_resize_textarea() -> (NodeRef, Callback<()>) {
-    let text_area_ref = use_node_ref();
-
-    let resize_textarea = {
-        let text_area_ref = text_area_ref.clone();
-        Callback::from(move |_| {
-            if let Some(text_area) = text_area_ref.cast::<HtmlTextAreaElement>()
-                && let Some(element) = text_area.dyn_ref::<HtmlElement>()
-            {
-                let _ = element.style().set_property("height", "auto");
-                let _ = element.style().set_property("overflow-y", "hidden");
-                let scroll_height = text_area.scroll_height();
-                let new_height = scroll_height.min(200);
-                let _ = element
-                    .style()
-                    .set_property("height", &format!("{new_height}px"));
-                if new_height >= 200 {
-                    let _ = element.style().set_property("overflow-y", "auto");
-                }
-            }
-        })
-    };
-
-    (text_area_ref, resize_textarea)
-}
-
-fn clear_input_and_reset(input_value: &UseStateHandle<String>, text_area_ref: &NodeRef) {
-    input_value.set(String::new());
-    if let Some(text_area) = text_area_ref.cast::<HtmlTextAreaElement>() {
-        text_area.set_value("");
-        if let Some(element) = text_area.dyn_ref::<HtmlElement>() {
-            let _ = element.style().set_property("height", "auto");
-        }
-    }
-}
-
-async fn read_file(file: File) -> Result<Vec<u8>, String> {
-    let file_reader = FileReader::new().map_err(|_| "Failed to create FileReader")?;
-
-    let (promise, resolve, reject) = {
-        let mut resolve = None;
-        let mut reject = None;
-        let promise = js_sys::Promise::new(&mut |res, rej| {
-            resolve = Some(res);
-            reject = Some(rej);
-        });
-        (promise, resolve.unwrap(), reject.unwrap())
-    };
-
-    {
-        let reader_clone = file_reader.clone();
-        let onload = Closure::<dyn FnMut(_)>::new(move |_: ProgressEvent| {
-            if let Ok(result) = reader_clone.result() {
-                let _ = resolve.call1(&wasm_bindgen::JsValue::NULL, &result);
-            }
-        });
-        file_reader.set_onload(Some(onload.as_ref().unchecked_ref()));
-        onload.forget();
-
-        let onerror = Closure::<dyn FnMut(_)>::new(move |_: ProgressEvent| {
-            let _ = reject.call1(
-                &wasm_bindgen::JsValue::NULL,
-                &wasm_bindgen::JsValue::from_str("Failed to read file"),
-            );
-        });
-        file_reader.set_onerror(Some(onerror.as_ref().unchecked_ref()));
-        onerror.forget();
-    }
-
-    file_reader
-        .read_as_array_buffer(&file)
-        .map_err(|_| "Failed to read file")?;
-
-    let result = JsFuture::from(promise)
-        .await
-        .map_err(|_| "Failed to read file")?;
-    let array_buffer = result
-        .dyn_into::<js_sys::ArrayBuffer>()
-        .map_err(|_| "Invalid ArrayBuffer")?;
-    let array = js_sys::Uint8Array::new(&array_buffer);
-    Ok(array.to_vec())
-}
-
-#[function_component(ChatInput)]
-pub fn chat_input(props: &ChatInputProps) -> Html {
-    let input_value = use_state(String::new);
-    let attachments = use_state(Vec::<Attachment>::new);
-    let error_message = use_state(|| Option::<String>::None);
-    let is_loading = use_state(|| false);
-    let file_input_ref = use_node_ref();
-    let (text_area_ref, resize_textarea) = use_auto_resize_textarea();
-
-    let _clear_error = {
-        let error_message = error_message.clone();
-        Callback::from(move |_: ()| {
-            error_message.set(None);
-        })
-    };
-
-    let handle_input = {
-        let input_value = input_value.clone();
-        let text_area_ref = text_area_ref.clone();
-        let resize_textarea = resize_textarea.clone();
-        Callback::from(move |_| {
-            if let Some(text_area) = text_area_ref.cast::<HtmlTextAreaElement>() {
-                input_value.set(text_area.value());
-                resize_textarea.emit(());
-            }
-        })
-    };
-
-    let handle_file_select = {
-        let attachments = attachments.clone();
-        let error_message = error_message.clone();
-        let is_loading = is_loading.clone();
-        let max_file_size = props.max_file_size;
-        let file_input_ref = file_input_ref.clone();
-
-        Callback::from(move |e: Event| {
-            let input = e.target_unchecked_into::<HtmlInputElement>();
-            if let Some(files) = input.files() {
-                let files_len = files.length();
-                if files_len > 0 {
-                    is_loading.set(true);
-                    error_message.set(None);
-
-                    let attachments = attachments.clone();
-                    let error_message = error_message.clone();
-                    let is_loading = is_loading.clone();
-                    let file_input_ref = file_input_ref.clone();
-
-                    wasm_bindgen_futures::spawn_local(async move {
-                        let mut new_attachments = (*attachments).clone();
-                        let mut has_error = false;
-
-                        for i in 0..files_len {
-                            if let Some(file) = files.item(i) {
-                                let size = file.size() as usize;
-                                if size > max_file_size {
-                                    error_message.set(Some(format!(
-                                        "{} is too large. Maximum size is {}",
-                                        file.name(),
-                                        format_file_size(max_file_size)
-                                    )));
-                                    has_error = true;
-                                    break;
-                                }
-
-                                match read_file(file.clone()).await {
-                                    Ok(data) => {
-                                        new_attachments.push(Attachment {
-                                            name: file.name(),
-                                            mime_type: file.type_(),
-                                            data,
-                                            size,
-                                        });
-                                    }
-                                    Err(err) => {
-                                        error_message.set(Some(err));
-                                        has_error = true;
-                                        break;
-                                    }
-                                }
-                            }
-                        }
-
-                        if !has_error {
-                            attachments.set(new_attachments);
-                        }
-                        is_loading.set(false);
-
-                        // Clear the file input
-                        if let Some(input) = file_input_ref.cast::<HtmlInputElement>() {
-                            input.set_value("");
-                        }
-                    });
-                }
-            }
-        })
-    };
-
-    let remove_attachment = {
-        let attachments = attachments.clone();
-        Callback::from(move |index: usize| {
-            let mut new_attachments = (*attachments).clone();
-            new_attachments.remove(index);
-            attachments.set(new_attachments);
-        })
-    };
-
-    let send_message = {
-        let input_value = input_value.clone();
-        let attachments = attachments.clone();
-        let on_send = props.on_send.clone();
-        let on_send_multimodal = props.on_send_multimodal.clone();
-        let text_area_ref = text_area_ref.clone();
-
-        Callback::from(move |_| {
-            let text = (*input_value).clone();
-            let has_text = !text.trim().is_empty();
-            let has_attachments = !attachments.is_empty();
-
-            if has_text || has_attachments {
-                if has_attachments || on_send_multimodal.is_some() {
-                    // Send as multimodal message
-                    if let Some(callback) = &on_send_multimodal {
-                        let message = MultimodalMessage::with_attachments(
-                            if has_text { Some(text) } else { None },
-                            (*attachments).clone(),
-                        );
-                        callback.emit(message);
-                    } else if has_text {
-                        // Fallback to text-only if no multimodal callback
-                        if let Some(callback) = on_send.as_ref() {
-                            callback.emit(text);
-                        }
-                    }
-                } else if has_text {
-                    // Send as text-only message
-                    if let Some(callback) = on_send.as_ref() {
-                        callback.emit(text);
-                    }
-                }
-
-                // Clear everything
-                clear_input_and_reset(&input_value, &text_area_ref);
-                attachments.set(Vec::new());
-            }
-        })
-    };
-
-    let handle_keydown = {
-        let send_message = send_message.clone();
-        Callback::from(move |e: KeyboardEvent| {
-            if e.key() == "Enter" && !e.shift_key() {
-                e.prevent_default();
-                send_message.emit(());
-            }
-        })
-    };
-
-    let handle_attachment_click = {
-        let file_input_ref = file_input_ref.clone();
-        Callback::from(move |_| {
-            if let Some(input) = file_input_ref.cast::<HtmlInputElement>() {
-                input.click();
-            }
-        })
-    };
-
-    // Auto-clear error after 5 seconds
-    {
-        let error_message = error_message.clone();
-        use_effect_with((*error_message).clone(), move |err| {
-            if err.is_some() {
-                let error_message = error_message.clone();
-                let timeout = Timeout::new(5000, move || {
-                    error_message.set(None);
-                });
-                timeout.forget();
-            }
-            || ()
-        });
-    }
-
-    let is_empty = input_value.trim().is_empty() && attachments.is_empty();
-    let placeholder = props
-        .placeholder
-        .clone()
-        .unwrap_or_else(|| "Type a message...".to_string());
-
-    let show_attachments = props.allow_images || props.allow_files;
-    let accept = match (props.allow_images, props.allow_files) {
-        (true, true) => "*/*",
-        (true, false) => "image/*",
-        (false, true) => "*/*",
-        (false, false) => "",
-    };
-
-    html! {
-        <div class={FLEX_COL}>
-            // Error message
-            if let Some(error) = &*error_message {
-                <div class={combine_styles(&["mx-4 mb-2 p-2 rounded-md bg-red-50 dark:bg-red-900/20", ERROR_TEXT, "text-sm"])}>
-                    {error}
-                </div>
-            }
-
-            // Attachment previews
-            if !attachments.is_empty() {
-                <div class="flex flex-wrap gap-2 px-4 pb-2">
-                    {for attachments.iter().enumerate().map(|(i, attachment)| {
-                        html! {
-                            <AttachmentPreview
-                                attachment={attachment.clone()}
-                                on_remove={
-                                    let remove_attachment = remove_attachment.clone();
-                                    Callback::from(move |_: MouseEvent| remove_attachment.emit(i))
-                                }
-                            />
-                        }
-                    })}
-                </div>
-            }
-
-            // Input area
-            <div class={combine_styles(&["flex items-end gap-3", STANDARD_PADDING, CARD_BG, "border-t", PRIMARY_BORDER])}>
-                // Hidden file input
-                if show_attachments {
-                    <input
-                        ref={file_input_ref}
-                        type="file"
-                        accept={accept}
-                        multiple={true}
-                        onchange={handle_file_select}
-                        class="hidden"
-                    />
-                }
-
-                // Attachment button
-                if show_attachments {
-                    <button
-                        onclick={handle_attachment_click}
-                        disabled={props.disabled || *is_loading}
-                        class={combine_styles(&[
-                            FLEX_CENTER, "justify-center w-10 h-10 p-0 rounded-lg",
-                            "text-gray-500 hover:text-gray-700 dark:text-gray-400 dark:hover:text-gray-200",
-                            "hover:bg-gray-100 dark:hover:bg-gray-700",
-                            TRANSITION_COLORS,
-                            "disabled:opacity-50 disabled:cursor-not-allowed"
-                        ])}
-                        title="Attach files"
-                    >
-                        <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
-                                d="M15.172 7l-6.586 6.586a2 2 0 102.828 2.828l6.414-6.586a4 4 0 00-5.656-5.656l-6.415 6.585a6 6 0 108.486 8.486L20.5 13" />
-                        </svg>
-                    </button>
-                }
-
-                // Text input
-                <div class="flex-1 relative">
-                    <textarea
-                        ref={text_area_ref}
-                        class={combine_styles(&["w-full min-h-[40px] max-h-[200px] px-3 py-2 border", INPUT_COLORS, "rounded-lg text-sm leading-relaxed resize-none outline-none overflow-hidden", TRANSITION_COLORS, CARD_BG, PRIMARY_TEXT, "focus:border-gray-400 focus:ring-1 focus:ring-gray-400 dark:focus:border-gray-500 dark:focus:ring-gray-500 disabled:bg-gray-100 disabled:cursor-not-allowed placeholder:text-gray-400 dark:placeholder:text-gray-600"])}
-                        placeholder={placeholder}
-                        value={(*input_value).clone()}
-                        oninput={handle_input}
-                        onkeydown={handle_keydown}
-                        disabled={props.disabled || *is_loading}
-                        rows="1"
-                    />
-                </div>
-
-                // Send button
-                <SendButton
-                    onclick={send_message}
-                    disabled={is_empty || props.disabled || *is_loading}
-                />
-            </div>
-        </div>
-    }
-}
-
-#[derive(Properties, PartialEq)]
-struct AttachmentPreviewProps {
-    pub attachment: Attachment,
-    pub on_remove: Callback<MouseEvent>,
-}
-
-#[function_component(AttachmentPreview)]
-fn attachment_preview(props: &AttachmentPreviewProps) -> Html {
-    let attachment = &props.attachment;
-
-    html! {
-        <div class="relative group">
-            if attachment.is_image() {
-                // Image preview
-                <div class="relative w-20 h-20 rounded-lg overflow-hidden bg-gray-100 dark:bg-gray-700">
-                    <img
-                        src={attachment.to_data_url()}
-                        alt={attachment.name.clone()}
-                        class="w-full h-full object-cover"
-                    />
-                    <div class="absolute inset-0 bg-black/50 opacity-0 group-hover:opacity-100 transition-opacity flex items-center justify-center">
-                        <button
-                            onclick={props.on_remove.clone()}
-                            class="p-1 bg-red-500 text-white rounded-full hover:bg-red-600"
-                            title="Remove attachment"
-                        >
-                            <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12" />
-                            </svg>
-                        </button>
-                    </div>
-                </div>
-            } else {
-                // File preview
-                <div class="flex items-center gap-2 px-3 py-2 bg-gray-100 dark:bg-gray-700 rounded-lg group-hover:bg-gray-200 dark:group-hover:bg-gray-600 transition-colors">
-                    <svg class="w-5 h-5 text-gray-500 dark:text-gray-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z" />
-                    </svg>
-                    <div class="flex flex-col">
-                        <span class="text-sm font-medium text-gray-700 dark:text-gray-300 truncate max-w-[100px]">
-                            {&attachment.name}
-                        </span>
-                        <span class="text-xs text-gray-500 dark:text-gray-400">
-                            {attachment.size_string()}
-                        </span>
-                    </div>
-                    <button
-                        onclick={props.on_remove.clone()}
-                        class="ml-2 p-1 text-gray-500 hover:text-red-500 dark:text-gray-400 dark:hover:text-red-400"
-                        title="Remove attachment"
-                    >
-                        <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12" />
-                        </svg>
-                    </button>
-                </div>
-            }
-        </div>
-    }
-}
-
-#[derive(Properties, PartialEq)]
-struct SendButtonProps {
-    pub onclick: Callback<()>,
-    pub disabled: bool,
-}
-
-#[function_component(SendButton)]
-fn send_button(props: &SendButtonProps) -> Html {
-    let handle_click = {
-        let onclick = props.onclick.clone();
-        Callback::from(move |_| onclick.emit(()))
-    };
-
-    html! {
-        <button
-            class={combine_styles(&[FLEX_CENTER, "justify-center w-[42px] h-[42px] p-0 rounded-lg bg-blue-500 dark:bg-blue-600 text-white cursor-pointer transition-all duration-200 flex-shrink-0 hover:bg-blue-600 dark:hover:bg-blue-700 disabled:bg-gray-200 disabled:cursor-not-allowed disabled:text-gray-400"])}
-            onclick={handle_click}
-            disabled={props.disabled}
-            title="Send message"
-            aria-label="Send message"
-        >
-            <svg class="w-5 h-5" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
-                <path d="M22 2L11 13" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
-                <path d="M22 2L15 22L11 13L2 9L22 2Z" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
-            </svg>
-        </button>
-    }
-}
-
-fn format_file_size(size: usize) -> String {
-    if size < 1024 {
-        format!("{size} B")
-    } else if size < 1024 * 1024 {
-        format!("{:.1} KB", size as f64 / 1024.0)
-    } else {
-        format!("{:.1} MB", size as f64 / (1024.0 * 1024.0))
-    }
-}
diff --git a/crates/chat-ui/src/components/message.rs b/crates/chat-ui/src/components/message.rs
deleted file mode 100644
index 54ac17f1..00000000
--- a/crates/chat-ui/src/components/message.rs
+++ /dev/null
@@ -1,353 +0,0 @@
-use crate::components::StreamingText;
-use crate::styles::{
-    ASSISTANT_BUBBLE_COLORS, DEFAULT_BUBBLE_COLORS, SYSTEM_BUBBLE_COLORS, TOOL_BUBBLE_COLORS,
-    USER_BUBBLE_COLORS,
-};
-use crate::types::ChatMessage;
-use crate::utils::markdown::render_markdown;
-use serde_json::Value;
-use web_sys::MouseEvent;
-use yew::prelude::*;
-
-#[derive(Properties, Clone, PartialEq)]
-pub struct MessageProps {
-    pub message: ChatMessage,
-    #[prop_or_default]
-    pub is_last: bool,
-    #[prop_or_default]
-    pub class: Classes,
-}
-
-#[function_component(Message)]
-pub fn message(props: &MessageProps) -> Html {
-    let MessageProps {
-        message,
-        is_last,
-        class,
-    } = props;
-
-    let expanded_tools = use_state(|| true); // Default to expanded for better visibility
-
-    let role_class = match message.role.as_str() {
-        "system" => "system",
-        "user" => "user",
-        "assistant" => "assistant",
-        "tool" | "function" => "tool",
-        _ => "unknown",
-    };
-
-    let role_label = match message.role.as_str() {
-        "system" => "System",
-        "user" => "User",
-        "assistant" => "Assistant",
-        "tool" => "Tool",
-        "function" => "Function",
-        _ => &message.role,
-    };
-
-    let toggle_tools = {
-        let expanded_tools = expanded_tools.clone();
-        Callback::from(move |_| {
-            expanded_tools.set(!*expanded_tools);
-        })
-    };
-
-    // Extract refusal from metadata
-    let refusal = message
-        .metadata
-        .get("refusal")
-        .and_then(|v| v.as_str())
-        .map(|s| s.to_string());
-
-    // Extract finish_reason from metadata
-    let finish_reason = message.finish_reason();
-
-    let message_class = match role_class {
-        "user" => USER_BUBBLE_COLORS,
-        "assistant" => ASSISTANT_BUBBLE_COLORS,
-        "system" => SYSTEM_BUBBLE_COLORS,
-        "tool" => TOOL_BUBBLE_COLORS,
-        _ => DEFAULT_BUBBLE_COLORS,
-    };
-
-    html! {
-        <div class={classes!("flex", "flex-col", "gap-2", "p-4", "rounded-lg", "shadow", message_class, class.clone())}>
-            <div class="flex gap-2 items-center">
-                <span class="font-semibold text-sm text-gray-600 dark:text-gray-400">{role_label}</span>
-                if message.name.is_some() {
-                    <span class="text-xs text-gray-500">{message.name.as_ref().unwrap()}</span>
-                }
-            </div>
-
-            <div class="leading-relaxed break-words">
-                {render_message_content(&message.content, message.is_streaming(), *is_last)}
-
-                if let Some(refusal_text) = refusal {
-                    <div class="bg-red-50 dark:bg-red-900 text-red-700 dark:text-red-300 px-3 py-2 rounded mt-2">
-                        <span class="font-semibold mr-2">{"Refusal:"}</span>
-                        <span>{refusal_text}</span>
-                    </div>
-                }
-
-                if let Some(tool_calls) = &message.tool_calls {
-                    <div class="mt-2">
-                        <button class="bg-transparent border-0 cursor-pointer text-sm text-blue-600 dark:text-blue-400 px-2 py-1 flex items-center gap-1 hover:bg-blue-50 dark:hover:bg-blue-900 rounded" onclick={toggle_tools}>
-                            <span class="text-xs w-3">{if *expanded_tools { "▼" } else { "▶" }}</span>
-                            <span class="text-base">{"🔧"}</span>
-                            {format!(" {} tool call{}", tool_calls.len(), if tool_calls.len() == 1 { "" } else { "s" })}
-                        </button>
-
-                        if *expanded_tools {
-                            <div class="mt-2 pl-5">
-                                {for tool_calls.iter().map(|tool_call| {
-                                    render_tool_call(tool_call)
-                                })}
-                            </div>
-                        }
-                    </div>
-                }
-            </div>
-
-            if let Some(reason) = finish_reason {
-                <div class="text-xs text-gray-500 italic mt-1">
-                    <span>{format!("Finish reason: {}", reason)}</span>
-                </div>
-            }
-
-            // Display any extra metadata that might be interesting
-            {render_extra_metadata(&message.metadata)}
-
-        </div>
-    }
-}
-
-fn render_message_content(content: &Option<Value>, is_streaming: bool, is_last: bool) -> Html {
-    match content {
-        None => html! { <span class="text-gray-400 dark:text-gray-400 italic">{"(empty)"}</span> },
-        Some(Value::String(text)) => {
-            if is_streaming && is_last {
-                html! {
-                    <StreamingText text={text.clone()} streaming={true} initial_delay_ms={20} final_delay_ms={4} />
-                }
-            } else {
-                render_markdown(text)
-            }
-        }
-        Some(Value::Array(parts)) => {
-            html! {
-                <>
-                    {for parts.iter().map(|part| {
-                        if let Some(text) = part.get("text").and_then(|t| t.as_str()) {
-                            if is_streaming && is_last {
-                                html! {
-                                    <StreamingText text={text.to_string()} streaming={true} initial_delay_ms={20} final_delay_ms={4} />
-                                }
-                            } else {
-                                render_markdown(text)
-                            }
-                        } else if let Some(image_url) = part.get("image_url") {
-                            // OpenAI format
-                            if let Some(url) = image_url.get("url").and_then(|u| u.as_str()) {
-                                html! {
-                                    <ImageDisplay url={url.to_string()} />
-                                }
-                            } else {
-                                html! {}
-                            }
-                        } else if part.get("type").and_then(|t| t.as_str()) == Some("image") {
-                            // Anthropic format
-                            if let Some(source) = part.get("source") {
-                                if let Some(data) = source.get("data").and_then(|d| d.as_str()) {
-                                    if let Some(media_type) = source.get("media_type").and_then(|m| m.as_str()) {
-                                        let url = format!("data:{media_type};base64,{data}");
-                                        html! {
-                                            <ImageDisplay url={url} />
-                                        }
-                                    } else {
-                                        html! {}
-                                    }
-                                } else {
-                                    html! {}
-                                }
-                            } else {
-                                html! {}
-                            }
-                        } else {
-                            // For other content types, show as JSON
-                            html! {
-                                <pre class="bg-gray-50 dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded p-2 font-mono text-xs overflow-x-auto whitespace-pre-wrap">
-                                    {serde_json::to_string_pretty(part).unwrap_or_default()}
-                                </pre>
-                            }
-                        }
-                    })}
-                </>
-            }
-        }
-        Some(Value::Object(obj)) => {
-            // Try to extract text content
-            if let Some(text) = obj.get("text").and_then(|t| t.as_str()) {
-                if is_streaming && is_last {
-                    html! {
-                        <StreamingText text={text.to_string()} streaming={true} initial_delay_ms={20} final_delay_ms={4} />
-                    }
-                } else {
-                    render_markdown(text)
-                }
-            } else {
-                // Show as formatted JSON
-                html! {
-                    <pre class="bg-gray-50 dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded p-2 font-mono text-xs overflow-x-auto whitespace-pre-wrap">
-                        {serde_json::to_string_pretty(obj).unwrap_or_default()}
-                    </pre>
-                }
-            }
-        }
-        Some(other) => {
-            // For other types, show as JSON
-            html! {
-                <pre class="bg-gray-50 dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded p-2 font-mono text-xs overflow-x-auto whitespace-pre-wrap">
-                    {serde_json::to_string_pretty(other).unwrap_or_default()}
-                </pre>
-            }
-        }
-    }
-}
-
-fn render_tool_call(tool_call: &Value) -> Html {
-    let id = tool_call
-        .get("id")
-        .and_then(|v| v.as_str())
-        .unwrap_or("unknown");
-
-    let function_name = tool_call
-        .get("function")
-        .and_then(|f| f.get("name"))
-        .and_then(|n| n.as_str())
-        .unwrap_or("unknown");
-
-    let args = tool_call
-        .get("function")
-        .and_then(|f| f.get("arguments"))
-        .and_then(|a| a.as_str())
-        .and_then(|args_str| serde_json::from_str::<Value>(args_str).ok())
-        .and_then(|v| serde_json::to_string_pretty(&v).ok())
-        .unwrap_or_else(|| {
-            tool_call
-                .get("function")
-                .and_then(|f| f.get("arguments"))
-                .and_then(|a| a.as_str())
-                .unwrap_or("")
-                .to_string()
-        });
-
-    html! {
-        <div class="bg-gray-100 dark:bg-gray-700 border border-gray-300 dark:border-gray-600 rounded p-3 mb-2">
-            <div class="font-semibold text-gray-700 dark:text-gray-300 mb-2">
-                {format!("{} ({})", function_name, id)}
-            </div>
-            <pre class="bg-gray-50 dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded p-2 font-mono text-xs overflow-x-auto whitespace-pre-wrap">
-                {args}
-            </pre>
-        </div>
-    }
-}
-
-fn render_extra_metadata(metadata: &std::collections::HashMap<String, Value>) -> Html {
-    // Filter out known fields that are already displayed
-    let skip_fields = ["finish_reason", "refusal", "is_streaming"];
-    let extra_fields: Vec<_> = metadata
-        .iter()
-        .filter(|(key, _)| !skip_fields.contains(&key.as_str()))
-        .collect();
-
-    if extra_fields.is_empty() {
-        return html! {};
-    }
-
-    html! {
-        <div class="text-xs text-gray-500 dark:text-gray-400 mt-2 p-2 bg-gray-50 dark:bg-gray-800 rounded">
-            {for extra_fields.iter().map(|(key, value)| {
-                html! {
-                    <div class="my-0.5">
-                        <span class="font-semibold mr-1">{format!("{}: ", key)}</span>
-                        <span>{format_metadata_value(value)}</span>
-                    </div>
-                }
-            })}
-        </div>
-    }
-}
-
-fn format_metadata_value(value: &Value) -> String {
-    match value {
-        Value::String(s) => s.clone(),
-        Value::Number(n) => n.to_string(),
-        Value::Bool(b) => b.to_string(),
-        Value::Null => "null".to_string(),
-        _ => serde_json::to_string(value).unwrap_or_default(),
-    }
-}
-
-#[derive(Properties, Clone, PartialEq)]
-struct ImageDisplayProps {
-    pub url: String,
-}
-
-#[function_component(ImageDisplay)]
-fn image_display(props: &ImageDisplayProps) -> Html {
-    let expanded = use_state(|| false);
-
-    let toggle_expanded = {
-        let expanded = expanded.clone();
-        Callback::from(move |_: MouseEvent| {
-            expanded.set(!*expanded);
-        })
-    };
-
-    if *expanded {
-        // Full screen overlay
-        html! {
-            <>
-                <div class="fixed inset-0 bg-black/90 z-50 flex items-center justify-center p-4"
-                     onclick={toggle_expanded.clone()}>
-                    <img
-                        src={props.url.clone()}
-                        alt="Expanded image"
-                        class="max-w-full max-h-full object-contain cursor-zoom-out"
-                        onclick={|e: MouseEvent| e.stop_propagation()}
-                    />
-                    <button
-                        class="absolute top-4 right-4 text-white bg-black/50 rounded-full p-2 hover:bg-black/70 transition-colors"
-                        onclick={toggle_expanded}
-                        title="Close"
-                    >
-                        <svg class="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12" />
-                        </svg>
-                    </button>
-                </div>
-                <div class="my-2 max-w-md">
-                    <img
-                        src={props.url.clone()}
-                        alt="Message image"
-                        class="max-w-full h-auto rounded-lg shadow-md cursor-zoom-in hover:shadow-lg transition-shadow"
-                    />
-                </div>
-            </>
-        }
-    } else {
-        // Thumbnail view
-        html! {
-            <div class="my-2 max-w-md">
-                <img
-                    src={props.url.clone()}
-                    alt="Message image"
-                    class="max-w-full h-auto rounded-lg shadow-md cursor-zoom-in hover:shadow-lg transition-shadow"
-                    onclick={toggle_expanded}
-                    title="Click to expand"
-                />
-            </div>
-        }
-    }
-}
diff --git a/crates/chat-ui/src/components/message_list.rs b/crates/chat-ui/src/components/message_list.rs
deleted file mode 100644
index faa9350d..00000000
--- a/crates/chat-ui/src/components/message_list.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-use crate::components::Message;
-use crate::styles::{FLEX_COL_GAP_4, STANDARD_PADDING};
-use crate::types::ChatMessage;
-use web_sys::Element;
-use yew::prelude::*;
-
-#[derive(Properties, Clone, PartialEq)]
-pub struct MessageListProps {
-    pub messages: Vec<ChatMessage>,
-    #[prop_or_default]
-    pub class: Classes,
-}
-
-#[function_component(MessageList)]
-pub fn message_list(props: &MessageListProps) -> Html {
-    let MessageListProps { messages, class } = props;
-
-    let container_ref = use_node_ref();
-
-    // Auto-scroll to bottom when new messages arrive
-    use_effect_with(messages.len(), {
-        let container_ref = container_ref.clone();
-        move |_| {
-            if let Some(element) = container_ref.cast::<Element>() {
-                element.set_scroll_top(element.scroll_height());
-            }
-        }
-    });
-
-    html! {
-        <div ref={container_ref} class={classes!(STANDARD_PADDING, FLEX_COL_GAP_4, class.clone())}>
-            {for messages.iter().enumerate().map(|(index, message)| {
-                html! {
-                    <Message
-                        key={index}
-                        message={message.clone()}
-                        is_last={index == messages.len() - 1}
-                    />
-                }
-            })}
-        </div>
-    }
-}
diff --git a/crates/chat-ui/src/components/mod.rs b/crates/chat-ui/src/components/mod.rs
deleted file mode 100644
index e8a7142c..00000000
--- a/crates/chat-ui/src/components/mod.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-mod chat_container;
-mod chat_input;
-mod message;
-mod message_list;
-mod streaming_indicator;
-mod streaming_text;
-
-pub use chat_container::ChatContainer;
-pub use chat_input::ChatInput;
-pub use message::Message;
-pub use message_list::MessageList;
-pub use streaming_indicator::StreamingIndicator;
-pub use streaming_text::StreamingText;
diff --git a/crates/chat-ui/src/components/streaming_indicator.rs b/crates/chat-ui/src/components/streaming_indicator.rs
deleted file mode 100644
index 4026d551..00000000
--- a/crates/chat-ui/src/components/streaming_indicator.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-use crate::styles::FLEX_CENTER;
-use yew::prelude::*;
-
-#[derive(Properties, Clone, PartialEq)]
-pub struct StreamingIndicatorProps {
-    #[prop_or_default]
-    pub class: Classes,
-}
-
-#[function_component(StreamingIndicator)]
-pub fn streaming_indicator(props: &StreamingIndicatorProps) -> Html {
-    let StreamingIndicatorProps { class } = props;
-
-    html! {
-        <div class={classes!(FLEX_CENTER, "py-2", "px-4", "mx-4", "mb-4", class.clone())}>
-            <div class="flex gap-1">
-                <span class="w-2 h-2 rounded-full bg-gray-600 dark:bg-gray-400 animate-pulse-dot" style="animation-delay: -0.32s;"></span>
-                <span class="w-2 h-2 rounded-full bg-gray-600 dark:bg-gray-400 animate-pulse-dot" style="animation-delay: -0.16s;"></span>
-                <span class="w-2 h-2 rounded-full bg-gray-600 dark:bg-gray-400 animate-pulse-dot"></span>
-            </div>
-        </div>
-    }
-}
diff --git a/crates/chat-ui/src/components/streaming_text.rs b/crates/chat-ui/src/components/streaming_text.rs
deleted file mode 100644
index 36bcf042..00000000
--- a/crates/chat-ui/src/components/streaming_text.rs
+++ /dev/null
@@ -1,202 +0,0 @@
-use crate::utils::markdown::render_markdown;
-use gloo_timers::callback::{Interval, Timeout};
-use std::cell::RefCell;
-use std::rc::Rc;
-use yew::prelude::*;
-
-#[derive(Properties, Clone, PartialEq)]
-pub struct StreamingTextProps {
-    pub text: String,
-    pub streaming: bool,
-    #[prop_or(25)]
-    pub initial_delay_ms: u32,
-    #[prop_or(5)]
-    pub final_delay_ms: u32,
-    #[prop_or_default]
-    pub class: Classes,
-}
-
-#[derive(Clone, PartialEq)]
-struct StreamingState {
-    current_text: String,
-    current_index: usize,
-    start_time: f64,
-}
-
-enum StreamingAction {
-    Reset,
-    Advance(String, usize), // text, index
-    SetComplete(String),
-}
-
-impl Reducible for StreamingState {
-    type Action = StreamingAction;
-
-    fn reduce(self: Rc<Self>, action: Self::Action) -> Rc<Self> {
-        let now = js_sys::Date::now();
-        match action {
-            StreamingAction::Reset => Rc::new(StreamingState {
-                current_text: String::new(),
-                current_index: 0,
-                start_time: now,
-            }),
-            StreamingAction::Advance(text, index) => Rc::new(StreamingState {
-                current_text: text,
-                current_index: index,
-                start_time: self.start_time,
-            }),
-            StreamingAction::SetComplete(text) => Rc::new(StreamingState {
-                current_text: text.clone(),
-                current_index: text.len(),
-                start_time: self.start_time,
-            }),
-        }
-    }
-}
-
-#[function_component(StreamingText)]
-pub fn streaming_text(props: &StreamingTextProps) -> Html {
-    let StreamingTextProps {
-        text,
-        streaming,
-        initial_delay_ms,
-        final_delay_ms,
-        class,
-    } = props;
-
-    let state = use_reducer(|| StreamingState {
-        current_text: String::new(),
-        current_index: 0,
-        start_time: js_sys::Date::now(),
-    });
-    let interval_handle = use_state(|| None::<Interval>);
-
-    // Reset when text changes
-    use_effect_with(text.clone(), {
-        let state = state.clone();
-        let interval_handle = interval_handle.clone();
-        move |_| {
-            interval_handle.set(None); // Clear interval
-            state.dispatch(StreamingAction::Reset);
-        }
-    });
-
-    // Streaming effect
-    use_effect_with(
-        (text.clone(), *streaming, *initial_delay_ms, *final_delay_ms),
-        {
-            let state = state.clone();
-            let interval_handle = interval_handle.clone();
-
-            move |(text, streaming, initial_delay, final_delay)| {
-                // Clone values to avoid lifetime issues
-                let text = text.clone();
-                let streaming = *streaming;
-                let initial_delay = *initial_delay;
-                let final_delay = *final_delay;
-
-                // Clear any existing interval
-                interval_handle.set(None);
-
-                if !streaming {
-                    // If not streaming, show all text immediately
-                    state.dispatch(StreamingAction::SetComplete(text));
-                    return;
-                }
-
-                // Start with empty text
-                state.dispatch(StreamingAction::Reset);
-
-                // Create interval for streaming animation
-                let current_idx = Rc::new(RefCell::new(0usize));
-                let _start_time = js_sys::Date::now();
-
-                let setup_next_interval = Rc::new(RefCell::new(None::<Box<dyn Fn()>>));
-                let setup_next_interval_clone = setup_next_interval.clone();
-
-                *setup_next_interval.borrow_mut() = Some(Box::new({
-                    let state = state.clone();
-                    let interval_handle = interval_handle.clone();
-                    let text = text.clone();
-                    let current_idx = current_idx.clone();
-                    let setup_next_interval = setup_next_interval_clone.clone();
-
-                    move || {
-                        let idx = *current_idx.borrow();
-
-                        if idx >= text.len() {
-                            // Done streaming, clear interval
-                            interval_handle.set(None);
-                            return;
-                        }
-
-                        // Find next character boundary to avoid splitting UTF-8
-                        let mut next_idx = idx + 1;
-                        while next_idx < text.len() && !text.is_char_boundary(next_idx) {
-                            next_idx += 1;
-                        }
-
-                        // Calculate progress and delay with aggressive acceleration
-                        let progress = next_idx as f64 / text.len() as f64;
-                        let normalized = progress.clamp(0.0, 1.0);
-                        // Much more aggressive exponential curve: -8.0 instead of -3.0
-                        let factor = 1.0 - (-8.0 * normalized).exp();
-                        let delay =
-                            initial_delay as f64 - (initial_delay - final_delay) as f64 * factor;
-                        let delay = delay.max(final_delay as f64) as u32;
-
-                        // Update displayed text
-                        let new_text = text[..next_idx].to_string();
-
-                        // Update both the display state and our local index
-                        state.dispatch(StreamingAction::Advance(new_text, next_idx));
-                        *current_idx.borrow_mut() = next_idx;
-
-                        // Schedule next update with dynamic delay
-                        if next_idx < text.len() {
-                            let setup_clone = setup_next_interval.clone();
-                            let timeout = Timeout::new(delay, move || {
-                                if let Some(ref setup_fn) = *setup_clone.borrow() {
-                                    setup_fn();
-                                }
-                            });
-                            timeout.forget();
-                        }
-                    }
-                }));
-
-                // Start the first interval
-                if let Some(ref setup_fn) = *setup_next_interval.borrow() {
-                    setup_fn();
-                }
-            }
-        },
-    );
-
-    // Cleanup interval on unmount
-    use_effect_with((), {
-        let interval_handle = interval_handle.clone();
-        move |_| {
-            move || {
-                interval_handle.set(None);
-            }
-        }
-    });
-
-    // Simple, clean rendering without character-level spans
-    let displayed_text = if *streaming {
-        &state.current_text
-    } else {
-        text
-    };
-
-    html! {
-        <div class={classes!("relative", "transition-opacity", "duration-150", "ease-out", class.clone())}>
-            {render_markdown(displayed_text)}
-
-            if *streaming && state.current_index < text.len() {
-                <span class="inline-block ml-0.5 text-gray-600 dark:text-gray-400 align-baseline animate-pulse">{"▋"}</span>
-            }
-        </div>
-    }
-}
diff --git a/crates/chat-ui/src/lib.rs b/crates/chat-ui/src/lib.rs
deleted file mode 100644
index 75b93e17..00000000
--- a/crates/chat-ui/src/lib.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-pub mod components;
-pub mod parsers;
-pub mod styles;
-pub mod types;
-pub mod utils;
-
-// Re-export main components
-pub use components::{ChatContainer, Message, MessageList, StreamingIndicator};
-pub use types::{
-    Attachment, ChatMessage, ChatResponse, ContentBlock, MessageContent, MessageRole,
-    MultimodalMessage, Provider, ToolCall, ToolResponse, Usage,
-};
-pub use utils::flexible_parser::parse_cassette;
diff --git a/crates/chat-ui/src/parsers/anthropic.rs b/crates/chat-ui/src/parsers/anthropic.rs
deleted file mode 100644
index b6e9fd85..00000000
--- a/crates/chat-ui/src/parsers/anthropic.rs
+++ /dev/null
@@ -1,138 +0,0 @@
-use crate::types::{ChatMessage, ChatResponse, Provider, Usage};
-use anyhow::Result;
-use serde_json::{Value, json};
-use std::collections::HashMap;
-
-/// Parse Anthropic API response
-pub fn parse_response(response: Value, request: Value) -> Result<ChatResponse> {
-    // Extract messages from request
-    let mut messages = parse_request_messages(&request);
-
-    // Parse the response content
-    if let Some(content_array) = response.get("content").and_then(|c| c.as_array()) {
-        let mut combined_content = Vec::new();
-        let mut tool_calls = Vec::new();
-
-        for content in content_array {
-            let content_type = content.get("type").and_then(|t| t.as_str()).unwrap_or("");
-
-            match content_type {
-                "text" => {
-                    if let Some(text) = content.get("text") {
-                        combined_content.push(json!({
-                            "type": "text",
-                            "text": text
-                        }));
-                    }
-                }
-                "tool_use" => {
-                    // Anthropic's tool format
-                    tool_calls.push(content.clone());
-                }
-                _ => {
-                    // Other content types (images, etc.)
-                    combined_content.push(content.clone());
-                }
-            }
-        }
-
-        // Create assistant message
-        let mut assistant_msg = ChatMessage {
-            role: "assistant".to_string(),
-            content: if combined_content.is_empty() {
-                None
-            } else if combined_content.len() == 1
-                && combined_content[0].get("type").and_then(|t| t.as_str()) == Some("text")
-            {
-                combined_content[0].get("text").cloned()
-            } else {
-                Some(Value::Array(combined_content))
-            },
-            tool_calls: if tool_calls.is_empty() {
-                None
-            } else {
-                Some(tool_calls)
-            },
-            name: None,
-            metadata: HashMap::new(),
-        };
-
-        // Add stop_reason as metadata
-        if let Some(stop_reason) = response.get("stop_reason") {
-            assistant_msg
-                .metadata
-                .insert("finish_reason".to_string(), stop_reason.clone());
-        }
-
-        messages.push(assistant_msg);
-    }
-
-    // Parse usage with field aliasing
-    let usage = response.get("usage").map(|usage_obj| Usage {
-        prompt_tokens: usage_obj
-            .get("input_tokens")
-            .and_then(|v| v.as_i64())
-            .map(|v| v as i32),
-        completion_tokens: usage_obj
-            .get("output_tokens")
-            .and_then(|v| v.as_i64())
-            .map(|v| v as i32),
-        total_tokens: None, // Anthropic doesn't provide total_tokens
-        metadata: serde_json::from_value(usage_obj.clone()).unwrap_or_default(),
-    });
-
-    // Build response with all metadata captured
-    let mut metadata: HashMap<String, Value> = serde_json::from_value(response.clone())?;
-    // Remove fields we've explicitly handled
-    metadata.remove("content");
-    metadata.remove("usage");
-    metadata.remove("id");
-    metadata.remove("model");
-
-    Ok(ChatResponse {
-        id: response
-            .get("id")
-            .and_then(|v| v.as_str())
-            .unwrap_or("")
-            .to_string(),
-        model: response
-            .get("model")
-            .and_then(|v| v.as_str())
-            .unwrap_or("")
-            .to_string(),
-        messages,
-        provider: Provider::Anthropic,
-        usage,
-        metadata,
-    })
-}
-
-fn parse_request_messages(request: &Value) -> Vec<ChatMessage> {
-    let mut messages = Vec::new();
-
-    // Add system message if present
-    if let Some(system) = request.get("system").and_then(|s| s.as_str()) {
-        messages.push(ChatMessage {
-            role: "system".to_string(),
-            content: Some(Value::String(system.to_string())),
-            tool_calls: None,
-            name: None,
-            metadata: Default::default(),
-        });
-    }
-
-    // Add user/assistant messages
-    if let Some(msgs) = request.get("messages").and_then(|m| m.as_array()) {
-        for msg in msgs {
-            if let Ok(mut message) = serde_json::from_value::<ChatMessage>(msg.clone()) {
-                // Anthropic uses "content" field which can be string or array
-                if let Some(content) = msg.get("content") {
-                    message.content = Some(content.clone());
-                }
-                messages.push(message);
-            }
-        }
-    }
-
-    messages
-}
diff --git a/crates/chat-ui/src/parsers/google.rs b/crates/chat-ui/src/parsers/google.rs
deleted file mode 100644
index 360d7abb..00000000
--- a/crates/chat-ui/src/parsers/google.rs
+++ /dev/null
@@ -1,194 +0,0 @@
-use crate::types::{ChatMessage, ChatResponse, Provider, Usage};
-use anyhow::Result;
-use serde_json::Value;
-use std::collections::HashMap;
-
-/// Parse Google API response
-pub fn parse_response(response: Value, request: Value) -> Result<ChatResponse> {
-    // Extract messages from request
-    let mut messages = parse_request_messages(&request);
-
-    // Parse candidates (Google's equivalent of choices)
-    if let Some(candidates) = response.get("candidates").and_then(|c| c.as_array()) {
-        for candidate in candidates {
-            if let Some(content) = candidate.get("content")
-                && let Some(parts) = content.get("parts").and_then(|p| p.as_array())
-            {
-                let role = content
-                    .get("role")
-                    .and_then(|r| r.as_str())
-                    .unwrap_or("model") // Google uses "model" instead of "assistant"
-                    .to_string();
-
-                // Extract function calls and regular content separately
-                let mut text_parts = Vec::new();
-                let mut function_calls = Vec::new();
-
-                for part in parts {
-                    if let Some(function_call) = part.get("functionCall") {
-                        // Convert Google functionCall to OpenAI-style tool call
-                        let tool_call =
-                            convert_google_function_call(function_call, function_calls.len());
-                        function_calls.push(tool_call);
-                    } else if let Some(text) = part.get("text") {
-                        text_parts.push(text.clone());
-                    } else {
-                        // For other content types, add to text parts as JSON
-                        text_parts.push(part.clone());
-                    }
-                }
-
-                // Build content from non-function parts
-                let content_value = if text_parts.is_empty() {
-                    None
-                } else if text_parts.len() == 1 {
-                    Some(text_parts[0].clone())
-                } else {
-                    Some(Value::Array(text_parts))
-                };
-
-                let mut message = ChatMessage {
-                    role: if role == "model" {
-                        "assistant".to_string()
-                    } else {
-                        role
-                    },
-                    content: content_value,
-                    tool_calls: if function_calls.is_empty() {
-                        None
-                    } else {
-                        Some(function_calls)
-                    },
-                    name: None,
-                    metadata: HashMap::new(),
-                };
-
-                // Add finish reason as metadata
-                if let Some(finish_reason) = candidate.get("finishReason") {
-                    message
-                        .metadata
-                        .insert("finish_reason".to_string(), finish_reason.clone());
-                }
-
-                messages.push(message);
-            }
-        }
-    }
-
-    // Parse usage metadata
-    let usage = response.get("usageMetadata").map(|usage_metadata| Usage {
-        prompt_tokens: usage_metadata
-            .get("promptTokenCount")
-            .and_then(|v| v.as_i64())
-            .map(|v| v as i32),
-        completion_tokens: usage_metadata
-            .get("candidatesTokenCount")
-            .and_then(|v| v.as_i64())
-            .map(|v| v as i32),
-        total_tokens: usage_metadata
-            .get("totalTokenCount")
-            .and_then(|v| v.as_i64())
-            .map(|v| v as i32),
-        metadata: serde_json::from_value(usage_metadata.clone()).unwrap_or_default(),
-    });
-
-    // Build response with all metadata
-    let mut metadata: HashMap<String, Value> = serde_json::from_value(response.clone())?;
-    metadata.remove("candidates");
-    metadata.remove("usageMetadata");
-
-    Ok(ChatResponse {
-        id: response
-            .get("id")
-            .and_then(|v| v.as_str())
-            .unwrap_or("")
-            .to_string(),
-        model: response
-            .get("modelVersion")
-            .or_else(|| response.get("model"))
-            .and_then(|v| v.as_str())
-            .unwrap_or("")
-            .to_string(),
-        messages,
-        provider: Provider::Google,
-        usage,
-        metadata,
-    })
-}
-
-fn parse_request_messages(request: &Value) -> Vec<ChatMessage> {
-    let mut messages = Vec::new();
-
-    // Add system instruction if present
-    if let Some(system_instruction) = request.get("systemInstruction")
-        && let Some(parts) = system_instruction.get("parts").and_then(|p| p.as_array())
-    {
-        let content = if parts.len() == 1 && parts[0].get("text").is_some() {
-            parts[0].get("text").cloned()
-        } else {
-            Some(Value::Array(parts.to_vec()))
-        };
-
-        messages.push(ChatMessage {
-            role: "system".to_string(),
-            content,
-            tool_calls: None,
-            name: None,
-            metadata: Default::default(),
-        });
-    }
-
-    // Add conversation contents
-    if let Some(contents) = request.get("contents").and_then(|c| c.as_array()) {
-        for content in contents {
-            let role = content
-                .get("role")
-                .and_then(|r| r.as_str())
-                .unwrap_or("user")
-                .to_string();
-
-            if let Some(parts) = content.get("parts").and_then(|p| p.as_array()) {
-                let content_value = if parts.len() == 1 && parts[0].get("text").is_some() {
-                    parts[0].get("text").cloned()
-                } else {
-                    Some(Value::Array(parts.to_vec()))
-                };
-
-                messages.push(ChatMessage {
-                    role: if role == "model" {
-                        "assistant".to_string()
-                    } else {
-                        role
-                    },
-                    content: content_value,
-                    tool_calls: None,
-                    name: None,
-                    metadata: Default::default(),
-                });
-            }
-        }
-    }
-
-    messages
-}
-
-/// Convert Google functionCall format to OpenAI tool call format
-fn convert_google_function_call(function_call: &Value, index: usize) -> Value {
-    let function_name = function_call
-        .get("name")
-        .and_then(|n| n.as_str())
-        .unwrap_or("unknown");
-
-    let empty_args = Value::Object(serde_json::Map::new());
-    let args = function_call.get("args").unwrap_or(&empty_args);
-
-    // Convert to OpenAI format
-    serde_json::json!({
-        "id": format!("call_{}", index),
-        "type": "function",
-        "function": {
-            "name": function_name,
-            "arguments": serde_json::to_string(args).unwrap_or_default()
-        }
-    })
-}
diff --git a/crates/chat-ui/src/parsers/mod.rs b/crates/chat-ui/src/parsers/mod.rs
deleted file mode 100644
index 42a38aea..00000000
--- a/crates/chat-ui/src/parsers/mod.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-pub mod anthropic;
-pub mod google;
-pub mod openai;
-pub mod streaming;
-
-use crate::types::{ChatResponse, Provider};
-use crate::utils::cassette_loader::CassetteInteraction;
-use anyhow::Result;
-use serde_json::Value;
-
-/// Decompress gzip data if needed
-fn decompress_response_body(
-    body: &str,
-    headers: &std::collections::HashMap<String, Vec<String>>,
-) -> Result<String> {
-    // Check if the response is gzip-compressed
-    let is_gzipped = headers
-        .get("Content-Encoding")
-        .or_else(|| headers.get("content-encoding"))
-        .map(|values| values.iter().any(|v| v.to_lowercase().contains("gzip")))
-        .unwrap_or(false);
-
-    if !is_gzipped {
-        return Ok(body.to_string());
-    }
-
-    // Try to decode base64 first (for binary YAML data)
-    // Since we decompress when capturing, just return the body as-is
-    Ok(body.to_string())
-}
-
-/// Parse a cassette interaction into a flexible chat response
-pub fn parse_interaction(interaction: &CassetteInteraction) -> Result<ChatResponse> {
-    let provider = Provider::from_uri(&interaction.request.uri);
-    let request_body: Value = serde_json::from_str(&interaction.request.body)?;
-
-    // Decompress response body if needed
-    let response_body = decompress_response_body(
-        &interaction.response.body.string,
-        &interaction.response.headers,
-    )?;
-
-    // Check if this is a streaming response (SSE format)
-    if response_body.starts_with("data: ")
-        || response_body.starts_with("event: ")
-        || response_body.contains("\ndata: ")
-    {
-        streaming::parse_streaming_response(&response_body, provider, request_body)
-    } else {
-        // Parse as regular JSON response
-        let response_json: Value = serde_json::from_str(&response_body)?;
-
-        match provider {
-            Provider::OpenAI => openai::parse_response(response_json, request_body),
-            Provider::Anthropic => anthropic::parse_response(response_json, request_body),
-            Provider::Google => google::parse_response(response_json, request_body),
-            Provider::Unknown(_) => {
-                // Generic parsing - just try to deserialize directly
-                let mut response: ChatResponse = serde_json::from_value(response_json)?;
-                response.provider = provider;
-                Ok(response)
-            }
-        }
-    }
-}
diff --git a/crates/chat-ui/src/parsers/openai.rs b/crates/chat-ui/src/parsers/openai.rs
deleted file mode 100644
index f7b08b5b..00000000
--- a/crates/chat-ui/src/parsers/openai.rs
+++ /dev/null
@@ -1,187 +0,0 @@
-use crate::types::{ChatMessage, ChatResponse, Provider};
-use anyhow::Result;
-use serde_json::Value;
-
-/// Parse OpenAI API response
-pub fn parse_response(response: Value, request: Value) -> Result<ChatResponse> {
-    // Extract messages from request
-    let messages = parse_request_messages(&request);
-
-    // Check if this is an error response first
-    if let Some(_error) = response.get("error") {
-        return parse_error_response(response, messages, &request);
-    }
-
-    // Handle different OpenAI response formats
-    if response.get("choices").is_some() {
-        // Chat Completions API
-        parse_chat_completion_response(response, messages)
-    } else if response.get("output").is_some() {
-        // Responses API (/v1/responses)
-        parse_responses_api_response(response, messages)
-    } else {
-        // Unknown format - try generic parsing
-        let mut chat_response: ChatResponse = match serde_json::from_value(response.clone()) {
-            Ok(resp) => resp,
-            Err(_) => {
-                // If parsing fails, create a basic response with the raw data
-                ChatResponse {
-                    id: response
-                        .get("id")
-                        .and_then(|v| v.as_str())
-                        .unwrap_or("unknown")
-                        .to_string(),
-                    model: response
-                        .get("model")
-                        .and_then(|v| v.as_str())
-                        .unwrap_or("unknown")
-                        .to_string(),
-                    messages,
-                    provider: Provider::OpenAI,
-                    usage: None,
-                    metadata: serde_json::from_value(response).unwrap_or_default(),
-                }
-            }
-        };
-        chat_response.provider = Provider::OpenAI;
-        Ok(chat_response)
-    }
-}
-
-fn parse_request_messages(request: &Value) -> Vec<ChatMessage> {
-    let mut messages = Vec::new();
-
-    // Try to extract messages from request
-    if let Some(msgs) = request.get("messages").and_then(|m| m.as_array()) {
-        for msg in msgs {
-            // Parse each message more carefully to handle multipart content
-            let role = msg
-                .get("role")
-                .and_then(|r| r.as_str())
-                .unwrap_or("user")
-                .to_string();
-
-            let content = msg.get("content").cloned();
-            let name = msg
-                .get("name")
-                .and_then(|n| n.as_str())
-                .map(|s| s.to_string());
-
-            messages.push(ChatMessage {
-                role,
-                content,
-                tool_calls: None,
-                name,
-                metadata: Default::default(),
-            });
-        }
-    } else if let Some(input) = request.get("input").and_then(|i| i.as_str()) {
-        // Responses API format
-        messages.push(ChatMessage {
-            role: "user".to_string(),
-            content: Some(Value::String(input.to_string())),
-            tool_calls: None,
-            name: None,
-            metadata: Default::default(),
-        });
-    }
-
-    messages
-}
-
-fn parse_chat_completion_response(
-    response: Value,
-    mut messages: Vec<ChatMessage>,
-) -> Result<ChatResponse> {
-    // Add assistant messages from choices
-    if let Some(choices) = response.get("choices").and_then(|c| c.as_array()) {
-        for choice in choices {
-            if let Some(message) = choice.get("message")
-                && let Ok(msg) = serde_json::from_value::<ChatMessage>(message.clone())
-            {
-                messages.push(msg);
-            }
-        }
-    }
-
-    // Create the response with all fields captured
-    let mut chat_response: ChatResponse = serde_json::from_value(response)?;
-    chat_response.provider = Provider::OpenAI;
-    chat_response.messages = messages;
-
-    Ok(chat_response)
-}
-
-fn parse_responses_api_response(
-    response: Value,
-    mut messages: Vec<ChatMessage>,
-) -> Result<ChatResponse> {
-    // Extract output messages
-    if let Some(outputs) = response.get("output").and_then(|o| o.as_array()) {
-        for output in outputs {
-            let role = output
-                .get("role")
-                .and_then(|r| r.as_str())
-                .unwrap_or("assistant")
-                .to_string();
-
-            let content = output
-                .get("content")
-                .cloned()
-                .or_else(|| Some(Value::Array(vec![])));
-
-            messages.push(ChatMessage {
-                role,
-                content,
-                tool_calls: None,
-                name: None,
-                metadata: Default::default(),
-            });
-        }
-    }
-
-    let mut chat_response: ChatResponse = serde_json::from_value(response)?;
-    chat_response.provider = Provider::OpenAI;
-    chat_response.messages = messages;
-
-    Ok(chat_response)
-}
-
-fn parse_error_response(
-    response: Value,
-    mut messages: Vec<ChatMessage>,
-    request: &Value,
-) -> Result<ChatResponse> {
-    // Add error as a system message
-    if let Some(error) = response.get("error") {
-        let error_message = error
-            .get("message")
-            .and_then(|m| m.as_str())
-            .unwrap_or("Unknown error")
-            .to_string();
-
-        messages.push(ChatMessage {
-            role: "system".to_string(),
-            content: Some(Value::String(error_message)),
-            tool_calls: None,
-            name: None,
-            metadata: Default::default(),
-        });
-    }
-
-    // Extract model from request instead of hardcoding "error"
-    let model = request
-        .get("model")
-        .and_then(|m| m.as_str())
-        .unwrap_or("unknown")
-        .to_string();
-
-    Ok(ChatResponse {
-        id: "error".to_string(),
-        model,
-        messages,
-        provider: Provider::OpenAI,
-        usage: None,
-        metadata: Default::default(),
-    })
-}
diff --git a/crates/chat-ui/src/parsers/streaming.rs b/crates/chat-ui/src/parsers/streaming.rs
deleted file mode 100644
index 1288e2b8..00000000
--- a/crates/chat-ui/src/parsers/streaming.rs
+++ /dev/null
@@ -1,290 +0,0 @@
-use crate::types::{ChatMessage, ChatResponse, Provider};
-use anyhow::Result;
-use serde_json::{Value, json};
-use std::collections::HashMap;
-
-/// Parse SSE streaming response data
-pub fn parse_streaming_response(
-    sse_data: &str,
-    provider: Provider,
-    request: Value,
-) -> Result<ChatResponse> {
-    match provider {
-        Provider::OpenAI => parse_openai_streaming(sse_data, request),
-        Provider::Anthropic => parse_anthropic_streaming(sse_data, request),
-        Provider::Google => parse_google_streaming(sse_data, request),
-        Provider::Unknown(_) => {
-            // Generic streaming - just create a message with the content
-            Ok(ChatResponse {
-                id: "streaming".to_string(),
-                model: "unknown".to_string(),
-                messages: vec![ChatMessage {
-                    role: "assistant".to_string(),
-                    content: Some(Value::String(sse_data.to_string())),
-                    tool_calls: None,
-                    name: None,
-                    metadata: Default::default(),
-                }],
-                provider,
-                usage: None,
-                metadata: Default::default(),
-            })
-        }
-    }
-}
-
-fn parse_openai_streaming(sse_data: &str, request: Value) -> Result<ChatResponse> {
-    let mut messages = extract_request_messages(&request);
-    let mut combined_content = String::new();
-    let mut model = String::new();
-    let mut id = String::new();
-    let mut metadata = HashMap::new();
-    let mut tool_calls: Vec<Value> = Vec::new();
-
-    // Parse each SSE chunk
-    for line in sse_data.lines() {
-        if let Some(data) = line.strip_prefix("data: ") {
-            let data = data.trim();
-
-            // Skip empty data lines
-            if data.is_empty() {
-                continue;
-            }
-
-            if data == "[DONE]" {
-                break;
-            }
-
-            match serde_json::from_str::<Value>(data) {
-                Ok(chunk) => {
-                    // Extract model and id from first chunk
-                    if model.is_empty() {
-                        if let Some(m) = chunk.get("model").and_then(|v| v.as_str()) {
-                            model = m.to_string();
-                        }
-                        if let Some(i) = chunk.get("id").and_then(|v| v.as_str()) {
-                            id = i.to_string();
-                        }
-
-                        // Store system_fingerprint and service_tier if present
-                        if let Some(sf) = chunk.get("system_fingerprint") {
-                            metadata.insert("system_fingerprint".to_string(), sf.clone());
-                        }
-                        if let Some(st) = chunk.get("service_tier") {
-                            metadata.insert("service_tier".to_string(), st.clone());
-                        }
-                    }
-
-                    // Extract content from choices
-                    if let Some(choices) = chunk.get("choices").and_then(|c| c.as_array()) {
-                        for choice in choices {
-                            if let Some(delta) = choice.get("delta") {
-                                // Handle text content
-                                if let Some(content) = delta.get("content").and_then(|c| c.as_str())
-                                {
-                                    combined_content.push_str(content);
-                                }
-
-                                // Handle tool calls
-                                if let Some(tcs) =
-                                    delta.get("tool_calls").and_then(|t| t.as_array())
-                                {
-                                    for tc in tcs {
-                                        tool_calls.push(tc.clone());
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                Err(e) => {
-                    // Log parsing error but continue processing
-                    eprintln!("Warning: Failed to parse OpenAI SSE data '{data}': {e}");
-                    continue;
-                }
-            }
-        }
-    }
-
-    // Create assistant message
-    let mut assistant_msg = ChatMessage {
-        role: "assistant".to_string(),
-        content: if combined_content.is_empty() {
-            None
-        } else {
-            Some(Value::String(combined_content))
-        },
-        tool_calls: if tool_calls.is_empty() {
-            None
-        } else {
-            Some(tool_calls)
-        },
-        name: None,
-        metadata: HashMap::new(),
-    };
-
-    // Mark as streaming if content is substantial
-    if assistant_msg.content.is_some() {
-        assistant_msg
-            .metadata
-            .insert("is_streaming".to_string(), json!(true));
-    }
-
-    messages.push(assistant_msg);
-
-    Ok(ChatResponse {
-        id,
-        model,
-        messages,
-        provider: Provider::OpenAI,
-        usage: None,
-        metadata,
-    })
-}
-
-fn parse_anthropic_streaming(sse_data: &str, request: Value) -> Result<ChatResponse> {
-    let mut messages = extract_request_messages(&request);
-    let mut combined_content = String::new();
-    let mut model = String::new();
-    let mut id = String::new();
-    let mut metadata = HashMap::new();
-
-    // Parse SSE events
-    for line in sse_data.lines() {
-        if let Some(data) = line.strip_prefix("data: ") {
-            let data = data.trim();
-
-            // Skip empty data lines
-            if data.is_empty() {
-                continue;
-            }
-
-            // Handle special termination markers
-            if data == "[DONE]" {
-                break;
-            }
-
-            match serde_json::from_str::<Value>(data) {
-                Ok(event) => {
-                    let event_type = event.get("type").and_then(|t| t.as_str()).unwrap_or("");
-
-                    match event_type {
-                        "message_start" => {
-                            if let Some(message) = event.get("message") {
-                                if let Some(m) = message.get("model").and_then(|v| v.as_str()) {
-                                    model = m.to_string();
-                                }
-                                if let Some(i) = message.get("id").and_then(|v| v.as_str()) {
-                                    id = i.to_string();
-                                }
-                            }
-                        }
-                        "content_block_delta" => {
-                            if let Some(delta) = event.get("delta")
-                                && let Some(text) = delta.get("text").and_then(|t| t.as_str())
-                            {
-                                combined_content.push_str(text);
-                            }
-                        }
-                        "message_delta" => {
-                            if let Some(delta) = event.get("delta")
-                                && let Some(stop_reason) = delta.get("stop_reason")
-                            {
-                                metadata.insert("stop_reason".to_string(), stop_reason.clone());
-                            }
-                        }
-                        _ => {}
-                    }
-                }
-                Err(e) => {
-                    // Log parsing error but continue processing
-                    eprintln!("Warning: Failed to parse SSE data '{data}': {e}");
-                    continue;
-                }
-            }
-        }
-    }
-
-    let mut assistant_msg = ChatMessage {
-        role: "assistant".to_string(),
-        content: if combined_content.is_empty() {
-            None
-        } else {
-            Some(Value::String(combined_content))
-        },
-        tool_calls: None,
-        name: None,
-        metadata: HashMap::new(),
-    };
-
-    if assistant_msg.content.is_some() {
-        assistant_msg
-            .metadata
-            .insert("is_streaming".to_string(), json!(true));
-    }
-
-    messages.push(assistant_msg);
-
-    Ok(ChatResponse {
-        id,
-        model,
-        messages,
-        provider: Provider::Anthropic,
-        usage: None,
-        metadata,
-    })
-}
-
-fn parse_google_streaming(_sse_data: &str, request: Value) -> Result<ChatResponse> {
-    // Google uses a different streaming format (not SSE)
-    // For now, treat it as a single response
-    let messages = extract_request_messages(&request);
-
-    Ok(ChatResponse {
-        id: "streaming".to_string(),
-        model: "google".to_string(),
-        messages,
-        provider: Provider::Google,
-        usage: None,
-        metadata: Default::default(),
-    })
-}
-
-/// Extract messages from request regardless of provider format
-fn extract_request_messages(request: &Value) -> Vec<ChatMessage> {
-    let mut messages = Vec::new();
-
-    // Common message extraction patterns
-    if let Some(msgs) = request.get("messages").and_then(|m| m.as_array()) {
-        for msg in msgs {
-            if let Ok(message) = serde_json::from_value::<ChatMessage>(msg.clone()) {
-                messages.push(message);
-            }
-        }
-    }
-
-    // System message (Anthropic style)
-    if let Some(system) = request.get("system").and_then(|s| s.as_str()) {
-        messages.insert(
-            0,
-            ChatMessage {
-                role: "system".to_string(),
-                content: Some(Value::String(system.to_string())),
-                tool_calls: None,
-                name: None,
-                metadata: Default::default(),
-            },
-        );
-    }
-
-    // Google contents format
-    if let Some(contents) = request.get("contents").and_then(|c| c.as_array()) {
-        for content in contents {
-            if let Ok(message) = serde_json::from_value::<ChatMessage>(content.clone()) {
-                messages.push(message);
-            }
-        }
-    }
-
-    messages
-}
diff --git a/crates/chat-ui/src/styles.rs b/crates/chat-ui/src/styles.rs
deleted file mode 100644
index d2b46070..00000000
--- a/crates/chat-ui/src/styles.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-//! Centralized style constants for consistent theming across the chat UI components
-
-// Background colors with dark mode support
-pub const CONTAINER_BG: &str = "bg-gray-50 dark:bg-gray-900";
-pub const CARD_BG: &str = "bg-white dark:bg-gray-800";
-pub const SECONDARY_BG: &str = "bg-gray-50 dark:bg-gray-700";
-pub const TERTIARY_BG: &str = "bg-gray-100 dark:bg-gray-700";
-
-// Text colors with dark mode support
-pub const PRIMARY_TEXT: &str = "text-gray-900 dark:text-gray-100";
-pub const SECONDARY_TEXT: &str = "text-gray-700 dark:text-gray-300";
-pub const TERTIARY_TEXT: &str = "text-gray-600 dark:text-gray-400";
-pub const MUTED_TEXT: &str = "text-gray-500 dark:text-gray-400";
-
-// Border colors with dark mode support
-pub const PRIMARY_BORDER: &str = "border-gray-200 dark:border-gray-700";
-pub const SECONDARY_BORDER: &str = "border-gray-300 dark:border-gray-600";
-
-// Status color pairs (background + text)
-pub const ERROR_BG: &str = "bg-red-50 dark:bg-red-900";
-pub const ERROR_TEXT: &str = "text-red-700 dark:text-red-300";
-pub const ERROR_BORDER: &str = "border-red-200 dark:border-red-700";
-
-pub const SUCCESS_BG: &str = "bg-green-50 dark:bg-green-900";
-pub const SUCCESS_TEXT: &str = "text-green-800 dark:text-green-200";
-
-pub const INFO_BG: &str = "bg-blue-50 dark:bg-blue-900";
-pub const INFO_TEXT: &str = "text-blue-800 dark:text-blue-200";
-
-pub const WARNING_BG: &str = "bg-orange-50 dark:bg-orange-900";
-pub const WARNING_TEXT: &str = "text-orange-800 dark:text-orange-200";
-
-// Message bubble styles (moved from message.rs)
-pub const USER_BUBBLE_COLORS: &str =
-    "bg-blue-100 dark:bg-blue-900 ml-10 md:ml-20 border border-blue-200 dark:border-blue-800";
-pub const ASSISTANT_BUBBLE_COLORS: &str =
-    "bg-white dark:bg-gray-700 mr-10 md:mr-20 border border-gray-200 dark:border-gray-600";
-pub const SYSTEM_BUBBLE_COLORS: &str =
-    "bg-orange-100 dark:bg-orange-900 italic border border-orange-200 dark:border-orange-800";
-pub const TOOL_BUBBLE_COLORS: &str =
-    "bg-blue-50 dark:bg-blue-900 font-mono text-sm border border-blue-200 dark:border-blue-800";
-pub const DEFAULT_BUBBLE_COLORS: &str = "bg-white border border-gray-200 dark:border-gray-700";
-
-// Button styles
-pub const PRIMARY_BUTTON: &str = "px-4 py-2 bg-blue-500 hover:bg-blue-600 text-white rounded-md transition-colors disabled:bg-gray-300 dark:disabled:bg-gray-600 disabled:cursor-not-allowed";
-pub const SECONDARY_BUTTON: &str = "px-4 py-2 bg-gray-200 hover:bg-gray-300 dark:bg-gray-700 dark:hover:bg-gray-600 text-gray-700 dark:text-gray-300 rounded-md transition-colors";
-pub const DANGER_BUTTON: &str =
-    "px-4 py-2 bg-red-500 hover:bg-red-600 text-white rounded-md transition-colors";
-
-// Input styles
-pub const INPUT_BASE: &str = "w-full px-3 py-2 border rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500";
-pub const INPUT_COLORS: &str =
-    "border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-gray-200";
-pub const TEXTAREA_BASE: &str = "w-full px-3 py-2 border rounded-md resize-none focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500";
-
-// Code block styles
-pub const CODE_BLOCK: &str = "bg-gray-50 dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded p-2 font-mono text-xs overflow-x-auto whitespace-pre-wrap";
-pub const INLINE_CODE: &str = "bg-gray-100 dark:bg-gray-700 px-1 py-0.5 rounded text-sm font-mono";
-
-// Common layout patterns
-pub const FLEX_COL: &str = "flex flex-col";
-pub const FLEX_COL_GAP_2: &str = "flex flex-col gap-2";
-pub const FLEX_COL_GAP_4: &str = "flex flex-col gap-4";
-pub const FLEX_CENTER: &str = "flex items-center";
-pub const FLEX_CENTER_GAP_2: &str = "flex items-center gap-2";
-pub const FLEX_BETWEEN: &str = "flex justify-between items-center";
-
-// Common spacing
-pub const CARD_PADDING: &str = "p-6";
-pub const STANDARD_PADDING: &str = "p-4";
-pub const HEADER_PADDING: &str = "px-4 py-3";
-pub const BUTTON_PADDING: &str = "px-3 py-2";
-
-// Shadows and rounded corners
-pub const CARD_SHADOW: &str = "shadow-md";
-pub const LIGHT_SHADOW: &str = "shadow-sm";
-pub const ROUNDED_STANDARD: &str = "rounded-lg";
-pub const ROUNDED_SMALL: &str = "rounded-md";
-
-// Transitions
-pub const TRANSITION_COLORS: &str = "transition-colors duration-200";
-pub const TRANSITION_ALL: &str = "transition-all duration-200";
-
-// Utility function to combine multiple style constants
-pub fn combine_styles(styles: &[&str]) -> String {
-    styles.join(" ")
-}
diff --git a/crates/chat-ui/src/types/mod.rs b/crates/chat-ui/src/types/mod.rs
deleted file mode 100644
index fabdd1f4..00000000
--- a/crates/chat-ui/src/types/mod.rs
+++ /dev/null
@@ -1,187 +0,0 @@
-mod multimodal;
-
-pub use multimodal::{Attachment, ContentBlock, ImageData, ImageSource, MultimodalMessage};
-
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-use std::collections::HashMap;
-
-/// Chat response that captures both typed and dynamic fields
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct ChatResponse {
-    // Core fields the UI needs
-    #[serde(default)]
-    pub id: String,
-
-    #[serde(default)]
-    pub model: String,
-
-    #[serde(default)]
-    pub messages: Vec<ChatMessage>,
-
-    // Provider is determined from URI, not from response
-    #[serde(skip)]
-    pub provider: Provider,
-
-    // Usage is common enough to deserve its own field
-    #[serde(default)]
-    pub usage: Option<Usage>,
-
-    // Everything else (service_tier, system_fingerprint, created, annotations, etc.)
-    #[serde(flatten)]
-    pub metadata: HashMap<String, Value>,
-}
-
-/// Message that captures both typed and dynamic fields
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct ChatMessage {
-    pub role: String,
-
-    #[serde(default)]
-    pub content: Option<Value>, // Can be string, array, or object
-
-    // Common fields
-    #[serde(default)]
-    pub tool_calls: Option<Vec<Value>>,
-
-    #[serde(default)]
-    pub name: Option<String>,
-
-    // Everything else (refusal, function_call, tool_call_id, etc.)
-    #[serde(flatten)]
-    pub metadata: HashMap<String, Value>,
-}
-
-/// Usage information
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Usage {
-    // Common fields across providers
-    #[serde(alias = "prompt_tokens", alias = "input_tokens")]
-    pub prompt_tokens: Option<i32>,
-
-    #[serde(alias = "completion_tokens", alias = "output_tokens")]
-    pub completion_tokens: Option<i32>,
-
-    #[serde(default)]
-    pub total_tokens: Option<i32>,
-
-    // Everything else (cache info, token details, etc.)
-    #[serde(flatten)]
-    pub metadata: HashMap<String, Value>,
-}
-
-/// Provider types
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum Provider {
-    OpenAI,
-    Anthropic,
-    Google,
-    Unknown(String),
-}
-
-impl Default for Provider {
-    fn default() -> Self {
-        Provider::Unknown("unknown".to_string())
-    }
-}
-
-impl Provider {
-    pub fn from_uri(uri: &str) -> Self {
-        if uri.contains("openai.com") {
-            Provider::OpenAI
-        } else if uri.contains("anthropic.com") {
-            Provider::Anthropic
-        } else if uri.contains("googleapis.com") || uri.contains("google.com") {
-            Provider::Google
-        } else {
-            Provider::Unknown(uri.to_string())
-        }
-    }
-}
-
-/// Helper methods for ChatMessage
-impl ChatMessage {
-    /// Create a new message with role and content
-    pub fn new(role: impl Into<String>, content: impl Into<String>) -> Self {
-        Self {
-            role: role.into(),
-            content: Some(Value::String(content.into())),
-            tool_calls: None,
-            name: None,
-            metadata: HashMap::new(),
-        }
-    }
-
-    /// Create a system message
-    pub fn system(content: impl Into<String>) -> Self {
-        Self::new("system", content)
-    }
-
-    /// Create a user message
-    pub fn user(content: impl Into<String>) -> Self {
-        Self::new("user", content)
-    }
-
-    /// Create an assistant message
-    pub fn assistant(content: impl Into<String>) -> Self {
-        Self::new("assistant", content)
-    }
-
-    /// Extract text content from various message formats
-    pub fn get_text_content(&self) -> Option<String> {
-        match &self.content {
-            Some(Value::String(s)) => Some(s.clone()),
-            Some(Value::Array(parts)) => {
-                // Handle multipart content
-                let texts: Vec<String> = parts
-                    .iter()
-                    .filter_map(|part| {
-                        if let Some(text) = part.get("text").and_then(|t| t.as_str()) {
-                            Some(text.to_string())
-                        } else {
-                            part.get("content")
-                                .and_then(|t| t.as_str())
-                                .map(|text| text.to_string())
-                        }
-                    })
-                    .collect();
-
-                if texts.is_empty() {
-                    None
-                } else {
-                    Some(texts.join(" "))
-                }
-            }
-            Some(Value::Object(obj)) => {
-                // Handle object with text field
-                obj.get("text")
-                    .or_else(|| obj.get("content"))
-                    .and_then(|v| v.as_str())
-                    .map(|s| s.to_string())
-            }
-            _ => None,
-        }
-    }
-
-    /// Check if this message indicates streaming
-    pub fn is_streaming(&self) -> bool {
-        self.metadata
-            .get("is_streaming")
-            .and_then(|v| v.as_bool())
-            .unwrap_or(false)
-    }
-
-    /// Get finish reason if available
-    pub fn finish_reason(&self) -> Option<String> {
-        self.metadata
-            .get("finish_reason")
-            .and_then(|v| v.as_str())
-            .map(|s| s.to_string())
-    }
-}
-
-// Legacy type aliases for compatibility
-pub type MessageRole = String;
-pub type MessageContent = Value;
-pub type ToolCall = Value;
-pub type ToolResponse = Value;
diff --git a/crates/chat-ui/src/types/multimodal.rs b/crates/chat-ui/src/types/multimodal.rs
deleted file mode 100644
index 63ed3899..00000000
--- a/crates/chat-ui/src/types/multimodal.rs
+++ /dev/null
@@ -1,115 +0,0 @@
-//! Types for multimodal message content (text, images, files)
-
-use serde::{Deserialize, Serialize};
-
-/// Represents different types of content that can be sent in a message
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(tag = "type", rename_all = "snake_case")]
-pub enum ContentBlock {
-    /// Plain text content
-    Text { text: String },
-    /// Image content (base64 encoded or URL)
-    #[serde(rename = "image_url")]
-    ImageUrl { image_url: ImageData },
-    /// Image content for Anthropic format
-    Image { source: ImageSource },
-}
-
-/// Image data that can be either a URL or base64 encoded
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct ImageData {
-    pub url: String, // Can be a URL or data:image/jpeg;base64,... format
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub detail: Option<String>, // OpenAI specific: "low", "high", "auto"
-}
-
-/// Anthropic-style image source
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct ImageSource {
-    #[serde(rename = "type")]
-    pub source_type: String, // "base64"
-    pub media_type: String, // "image/jpeg", "image/png", etc.
-    pub data: String,       // base64 encoded image data
-}
-
-/// Represents an attachment that can be added to a message
-#[derive(Clone, Debug, PartialEq)]
-pub struct Attachment {
-    pub name: String,
-    pub mime_type: String,
-    pub data: Vec<u8>, // Raw file data before encoding
-    pub size: usize,
-}
-
-impl Attachment {
-    /// Convert to base64 data URL format
-    pub fn to_data_url(&self) -> String {
-        use base64::Engine;
-        let base64_data = base64::engine::general_purpose::STANDARD.encode(&self.data);
-        format!("data:{};base64,{}", self.mime_type, base64_data)
-    }
-
-    /// Check if this attachment is an image
-    pub fn is_image(&self) -> bool {
-        self.mime_type.starts_with("image/")
-    }
-
-    /// Get a human-readable size string
-    pub fn size_string(&self) -> String {
-        if self.size < 1024 {
-            format!("{} B", self.size)
-        } else if self.size < 1024 * 1024 {
-            format!("{:.1} KB", self.size as f64 / 1024.0)
-        } else {
-            format!("{:.1} MB", self.size as f64 / (1024.0 * 1024.0))
-        }
-    }
-}
-
-/// Message content that can include text and attachments
-#[derive(Clone, Debug, PartialEq)]
-pub struct MultimodalMessage {
-    pub text: Option<String>,
-    pub attachments: Vec<Attachment>,
-}
-
-impl MultimodalMessage {
-    /// Create a text-only message
-    pub fn text(text: String) -> Self {
-        Self {
-            text: Some(text),
-            attachments: Vec::new(),
-        }
-    }
-
-    /// Create a message with attachments
-    pub fn with_attachments(text: Option<String>, attachments: Vec<Attachment>) -> Self {
-        Self { text, attachments }
-    }
-
-    /// Convert to content blocks for API submission
-    pub fn to_content_blocks(&self) -> Vec<ContentBlock> {
-        let mut blocks = Vec::new();
-
-        // Add images first (following best practices)
-        for attachment in &self.attachments {
-            if attachment.is_image() {
-                blocks.push(ContentBlock::ImageUrl {
-                    image_url: ImageData {
-                        url: attachment.to_data_url(),
-                        detail: None,
-                    },
-                });
-            }
-        }
-
-        // Add text content after images
-        if let Some(text) = &self.text
-            && !text.trim().is_empty()
-        {
-            blocks.push(ContentBlock::Text { text: text.clone() });
-        }
-
-        blocks
-    }
-}
diff --git a/crates/chat-ui/src/utils/cassette_loader.rs b/crates/chat-ui/src/utils/cassette_loader.rs
deleted file mode 100644
index ee551cfd..00000000
--- a/crates/chat-ui/src/utils/cassette_loader.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-use anyhow::Result;
-use serde::{Deserialize, Deserializer, Serialize};
-use std::collections::HashMap;
-
-/// Raw HTTP request data from cassette
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RawRequest {
-    pub uri: String,
-    pub method: String,
-    #[serde(default)]
-    pub headers: HashMap<String, Vec<String>>,
-    pub body: String,
-}
-
-/// Raw HTTP response data from cassette
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RawResponse {
-    #[serde(default = "default_status", deserialize_with = "deserialize_status")]
-    pub status: u16,
-    #[serde(default)]
-    pub headers: HashMap<String, Vec<String>>,
-    pub body: ResponseBody,
-}
-
-fn default_status() -> u16 {
-    200
-}
-
-/// Deserialize status from either a number or an object with a "code" field
-fn deserialize_status<'de, D>(deserializer: D) -> Result<u16, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    use serde::de::{self, Visitor};
-    use serde_json::Value;
-
-    struct StatusVisitor;
-
-    impl<'de> Visitor<'de> for StatusVisitor {
-        type Value = u16;
-
-        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-            formatter.write_str("a u16 or an object with a 'code' field")
-        }
-
-        fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
-        where
-            E: de::Error,
-        {
-            Ok(value as u16)
-        }
-
-        fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
-        where
-            M: de::MapAccess<'de>,
-        {
-            let mut code = None;
-
-            while let Some(key) = map.next_key::<String>()? {
-                if key == "code" {
-                    code = Some(map.next_value::<u16>()?);
-                } else {
-                    // Skip other fields like "message"
-                    map.next_value::<Value>()?;
-                }
-            }
-
-            code.ok_or_else(|| de::Error::missing_field("code"))
-        }
-    }
-
-    deserializer.deserialize_any(StatusVisitor)
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ResponseBody {
-    pub string: String,
-}
-
-/// A single HTTP interaction from a cassette
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct CassetteInteraction {
-    pub request: RawRequest,
-    pub response: RawResponse,
-}
-
-/// Root structure of a cassette file
-#[derive(Debug, Clone, Serialize, Deserialize)]
-struct CassetteFile {
-    interactions: Vec<CassetteInteraction>,
-}
-
-/// Load a cassette file and return the first interaction
-///
-/// This is a simple, dumb loader that just parses the JSON
-/// and returns the raw HTTP data without any interpretation
-pub fn load_cassette(json_content: &str) -> Result<CassetteInteraction> {
-    let cassette: CassetteFile = serde_json::from_str(json_content)?;
-
-    cassette
-        .interactions
-        .into_iter()
-        .next()
-        .ok_or_else(|| anyhow::anyhow!("No interactions found in cassette"))
-}
-
-/// Load all interactions from a cassette file
-pub fn load_all_interactions(json_content: &str) -> Result<Vec<CassetteInteraction>> {
-    let cassette: CassetteFile = serde_json::from_str(json_content)?;
-    Ok(cassette.interactions)
-}
diff --git a/crates/chat-ui/src/utils/cassette_parser.rs b/crates/chat-ui/src/utils/cassette_parser.rs
deleted file mode 100644
index a32980d5..00000000
--- a/crates/chat-ui/src/utils/cassette_parser.rs
+++ /dev/null
@@ -1,1084 +0,0 @@
-use crate::types::{ChatMessage, ChatResponse, MessageRole, Provider, ToolCall, Usage};
-use anyhow::{Context, Result};
-use serde::Deserialize;
-use serde_json::Value;
-
-// Helper macro for console logging that works in both WASM and non-WASM environments
-macro_rules! console_warn {
-    ($($arg:tt)*) => {
-        #[cfg(target_arch = "wasm32")]
-        web_sys::console::warn_1(&format!($($arg)*).into());
-        #[cfg(not(target_arch = "wasm32"))]
-        eprintln!("WARN: {}", format!($($arg)*));
-    };
-}
-
-macro_rules! console_error {
-    ($($arg:tt)*) => {
-        #[cfg(target_arch = "wasm32")]
-        web_sys::console::error_1(&format!($($arg)*).into());
-        #[cfg(not(target_arch = "wasm32"))]
-        eprintln!("ERROR: {}", format!($($arg)*));
-    };
-}
-
-#[derive(Debug, Deserialize)]
-struct CassetteFile {
-    interactions: Vec<Interaction>,
-}
-
-#[derive(Debug, Deserialize)]
-struct Interaction {
-    request: Request,
-    response: Response,
-}
-
-#[derive(Debug, Deserialize)]
-struct Request {
-    body: String,
-    uri: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct Response {
-    body: ResponseBody,
-}
-
-#[derive(Debug, Deserialize)]
-struct ResponseBody {
-    string: String,
-}
-
-// OpenAI response structures
-#[derive(Debug, Deserialize)]
-struct OpenAIResponse {
-    id: String,
-    model: String,
-    choices: Vec<OpenAIChoice>,
-    usage: Option<OpenAIUsage>,
-    created: Option<i64>,
-}
-
-// OpenAI error response structure
-#[derive(Debug, Deserialize)]
-struct OpenAIErrorResponse {
-    error: OpenAIError,
-}
-
-#[derive(Debug, Deserialize)]
-#[allow(dead_code)]
-struct OpenAIError {
-    message: String,
-    #[serde(rename = "type")]
-    error_type: String,
-    param: Option<String>,
-    code: Option<String>,
-}
-
-// OpenAI Responses API structure (/v1/responses)
-#[derive(Debug, Deserialize)]
-struct OpenAIResponsesResponse {
-    id: String,
-    model: String,
-    output: Vec<OpenAIOutput>,
-    usage: Option<OpenAIResponsesUsage>,
-    created_at: Option<i64>,
-}
-
-#[derive(Debug, Deserialize)]
-#[allow(dead_code)]
-struct OpenAIOutput {
-    id: String,
-    #[serde(rename = "type")]
-    output_type: String,
-    content: Vec<OpenAIOutputContent>,
-    role: String,
-}
-
-#[derive(Debug, Deserialize)]
-#[allow(dead_code)]
-struct OpenAIOutputContent {
-    #[serde(rename = "type")]
-    content_type: String,
-    text: Option<String>,
-    image_url: Option<serde_json::Value>, // For image content
-}
-
-#[derive(Debug, Deserialize)]
-struct OpenAIResponsesUsage {
-    input_tokens: Option<i32>,
-    output_tokens: Option<i32>,
-    total_tokens: Option<i32>,
-}
-
-#[derive(Debug, Deserialize)]
-struct OpenAIChoice {
-    message: OpenAIMessage,
-    finish_reason: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct OpenAIMessage {
-    role: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    content: Option<serde_json::Value>, // Can be string or array
-    tool_calls: Option<Vec<OpenAIToolCall>>,
-    refusal: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct OpenAIToolCall {
-    id: String,
-    #[serde(rename = "type")]
-    tool_type: String,
-    function: OpenAIFunction,
-}
-
-#[derive(Debug, Deserialize)]
-struct OpenAIFunction {
-    name: String,
-    arguments: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct OpenAIUsage {
-    prompt_tokens: Option<i32>,
-    completion_tokens: Option<i32>,
-    total_tokens: Option<i32>,
-}
-
-// Anthropic response structures
-#[derive(Debug, Deserialize)]
-struct AnthropicResponse {
-    id: String,
-    model: String,
-    content: Vec<AnthropicContent>,
-    usage: Option<AnthropicUsage>,
-    stop_reason: Option<String>,
-    stop_sequence: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-#[allow(dead_code)]
-struct AnthropicContent {
-    #[serde(rename = "type")]
-    content_type: String,
-    text: Option<String>,
-    // Tool use fields
-    id: Option<String>,
-    name: Option<String>,
-    input: Option<serde_json::Value>,
-}
-
-#[derive(Debug, Deserialize)]
-struct AnthropicUsage {
-    input_tokens: Option<i32>,
-    output_tokens: Option<i32>,
-}
-
-pub fn parse_cassette(json_content: &str) -> Result<ChatResponse> {
-    let cassette: CassetteFile = serde_json::from_str(json_content)
-        .map_err(|e| {
-            console_error!("Failed to parse cassette JSON: {}", e);
-            e
-        })
-        .context("Failed to parse cassette JSON")?;
-    
-    if cassette.interactions.is_empty() {
-        anyhow::bail!("No interactions found in cassette");
-    }
-    
-    let interaction = &cassette.interactions[0];
-    let provider = detect_provider(&interaction.request.uri);
-    
-    // Parse request to get the messages
-    let request_body: Value = serde_json::from_str(&interaction.request.body)
-        .context("Failed to parse request body")?;
-    
-    let mut messages = parse_request_messages(&request_body, &provider)?;
-    
-    // Parse response based on provider
-    let chat_response = match &provider {
-        Provider::OpenAI => {
-            parse_openai_response(&interaction.response.body.string, &mut messages)
-                .map_err(|e| {
-                    console_error!("Failed to parse OpenAI response: {}", e);
-                    e
-                })
-        }
-        Provider::Anthropic => {
-            parse_anthropic_response(&interaction.response.body.string, &mut messages)
-                .map_err(|e| {
-                    console_error!("Failed to parse Anthropic response: {}", e);
-                    e
-                })
-        }
-        Provider::Google => {
-            parse_google_response(&interaction.response.body.string, &mut messages)
-                .map_err(|e| {
-                    console_error!("Failed to parse Google response: {}", e);
-                    e
-                })
-        }
-        Provider::Unknown(uri) => {
-            console_warn!("Unknown provider for URI: {}. Attempting generic parsing.", uri);
-            // Create a basic response with the raw messages
-            Ok(ChatResponse {
-                id: "unknown".to_string(),
-                model: "unknown".to_string(),
-                messages: messages.clone(),
-                usage: None,
-                created: None,
-                provider: provider.clone(),
-            })
-        }
-    }?;
-
-    // Don't automatically mark messages as streaming - only use actual streaming data from cassettes
-    // This was causing all assistant messages to appear as "streaming" and disabling the input
-    // apply_smart_streaming(&mut chat_response.messages);
-    
-    Ok(chat_response)
-}
-
-
-fn detect_provider(uri: &str) -> Provider {
-    if uri.contains("openai.com") {
-        Provider::OpenAI
-    } else if uri.contains("anthropic.com") {
-        Provider::Anthropic
-    } else if uri.contains("google") || uri.contains("generativelanguage") {
-        Provider::Google
-    } else {
-        Provider::Unknown(uri.to_string())
-    }
-}
-
-fn parse_request_messages(request_body: &Value, provider: &Provider) -> Result<Vec<ChatMessage>> {
-    let mut messages = Vec::new();
-    
-    match provider {
-        Provider::OpenAI => {
-            // Handle both Chat Completions API (messages) and Responses API (input)
-            if let Some(msgs) = request_body["messages"].as_array() {
-                // Chat Completions API format
-                for msg in msgs {
-                    let role = msg["role"].as_str().unwrap_or("user");
-                    
-                    // Handle different content formats
-                    let message = if let Some(content_str) = msg["content"].as_str() {
-                        // Simple string content
-                        ChatMessage::new(parse_role(role), content_str.to_string())
-                    } else if let Some(content_array) = msg["content"].as_array() {
-                        // Array of content parts (multimodal)
-                        let mut parts = Vec::new();
-                        for part in content_array {
-                            if let Some(part_type) = part["type"].as_str() {
-                                match part_type {
-                                    "text" => {
-                                        if let Some(text) = part["text"].as_str() {
-                                            parts.push(crate::types::MessagePart::Text {
-                                                part_type: "text".to_string(),
-                                                text: text.to_string(),
-                                            });
-                                        }
-                                    }
-                                    "image_url" => {
-                                        if let Some(image_obj) = part["image_url"].as_object() {
-                                            if let Some(url) = image_obj.get("url").and_then(|v| v.as_str()) {
-                                                parts.push(crate::types::MessagePart::Image {
-                                                    part_type: "image_url".to_string(),
-                                                    image_url: crate::types::ImageContent {
-                                                        url: url.to_string(),
-                                                        detail: image_obj.get("detail").and_then(|v| v.as_str()).map(|s| s.to_string()),
-                                                    },
-                                                });
-                                            }
-                                        }
-                                    }
-                                    unknown_type => {
-                                        console_warn!("Unknown OpenAI content part type in request: {}", unknown_type);
-                                    }
-                                }
-                            }
-                        }
-                        let msg = ChatMessage {
-                            role: parse_role(role),
-                            content: Some(crate::types::MessageContent::Parts(parts)),
-                            name: None,
-                            tool_calls: None,
-                            tool_call_id: None,
-                            refusal: None,
-                            is_streaming: false,
-                            finish_reason: None,
-                            metadata: Default::default(),
-                        };
-                        msg
-                    } else {
-                        // Empty content
-                        ChatMessage::new(parse_role(role), String::new())
-                    };
-                    
-                    messages.push(message);
-                }
-            } else if let Some(input) = request_body["input"].as_str() {
-                // Responses API format
-                messages.push(ChatMessage::new(
-                    MessageRole::User,
-                    input.to_string(),
-                ));
-            }
-        }
-        Provider::Anthropic => {
-            if let Some(msgs) = request_body["messages"].as_array() {
-                for msg in msgs {
-                    let role = msg["role"].as_str().unwrap_or("user");
-                    
-                    // Handle different content formats for Anthropic
-                    let message = if let Some(content_str) = msg["content"].as_str() {
-                        // Simple string content
-                        ChatMessage::new(parse_role(role), content_str.to_string())
-                    } else if let Some(content_array) = msg["content"].as_array() {
-                        // Array of content parts (multimodal)
-                        let mut parts = Vec::new();
-                        for part in content_array {
-                            if let Some(part_type) = part["type"].as_str() {
-                                match part_type {
-                                    "text" => {
-                                        if let Some(text) = part["text"].as_str() {
-                                            parts.push(crate::types::MessagePart::Text {
-                                                part_type: "text".to_string(),
-                                                text: text.to_string(),
-                                            });
-                                        }
-                                    }
-                                    "image" => {
-                                        // Anthropic uses a different format for images
-                                        if let Some(source) = part["source"].as_object() {
-                                            if let Some(data) = source["data"].as_str() {
-                                                let media_type = source["media_type"].as_str().unwrap_or("image/jpeg");
-                                                let url = format!("data:{};base64,{}", media_type, data);
-                                                parts.push(crate::types::MessagePart::Image {
-                                                    part_type: "image".to_string(),
-                                                    image_url: crate::types::ImageContent {
-                                                        url,
-                                                        detail: None,
-                                                    },
-                                                });
-                                            }
-                                        }
-                                    }
-                                    unknown_type => {
-                                        console_warn!("Unknown Anthropic content part type in request: {}", unknown_type);
-                                    }
-                                }
-                            }
-                        }
-                        let msg = ChatMessage {
-                            role: parse_role(role),
-                            content: Some(crate::types::MessageContent::Parts(parts)),
-                            name: None,
-                            tool_calls: None,
-                            tool_call_id: None,
-                            refusal: None,
-                            is_streaming: false,
-                            finish_reason: None,
-                            metadata: Default::default(),
-                        };
-                        msg
-                    } else {
-                        // Empty content
-                        ChatMessage::new(parse_role(role), String::new())
-                    };
-                    
-                    messages.push(message);
-                }
-            }
-        }
-        Provider::Google => {
-            if let Some(contents) = request_body["contents"].as_array() {
-                for content in contents {
-                    let role = content["role"].as_str().unwrap_or("user");
-                    if let Some(parts) = content["parts"].as_array() {
-                        for part in parts {
-                            if let Some(text) = part["text"].as_str() {
-                                messages.push(ChatMessage::new(
-                                    parse_role(role),
-                                    text.to_string(),
-                                ));
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        _ => {
-            console_warn!("Unsupported provider in request parsing: {:?}", provider);
-        }
-    }
-    
-    Ok(messages)
-}
-
-fn parse_role(role: &str) -> MessageRole {
-    match role.to_lowercase().as_str() {
-        "system" => MessageRole::System,
-        "user" => MessageRole::User,
-        "assistant" | "model" => MessageRole::Assistant,
-        "tool" | "function" => MessageRole::Tool,
-        _ => MessageRole::User,
-    }
-}
-
-fn parse_openai_response(response_str: &str, messages: &mut Vec<ChatMessage>) -> Result<ChatResponse> {
-    // Handle streaming responses
-    if response_str.starts_with("data:") {
-        return parse_openai_streaming_response(response_str, messages);
-    }
-    
-    // Check for error responses first
-    if let Ok(error_response) = serde_json::from_str::<OpenAIErrorResponse>(response_str) {
-        let error_message = format!("OpenAI Error ({}): {}", 
-            error_response.error.error_type, 
-            error_response.error.message
-        );
-        
-        // Add error as a system message
-        messages.push(ChatMessage::new(
-            crate::types::MessageRole::System,
-            error_message.clone(),
-        ));
-        
-        return Ok(ChatResponse {
-            id: "error".to_string(),
-            model: "error".to_string(),
-            messages: messages.clone(),
-            usage: None,
-            created: None,
-            provider: crate::types::Provider::OpenAI,
-        });
-    }
-    
-    // Try parsing as Responses API first (has "output" field)
-    if let Ok(responses_response) = serde_json::from_str::<OpenAIResponsesResponse>(response_str) {
-        return parse_openai_responses_api(responses_response, messages);
-    }
-    
-    // Fall back to Chat Completions API (has "choices" field)
-    let response: OpenAIResponse = serde_json::from_str(response_str)
-        .context("Failed to parse OpenAI response")?;
-    
-    for choice in response.choices {
-        // Parse content which can be either a string or array of parts
-        let message_content = if let Some(content_value) = &choice.message.content {
-            match content_value {
-                serde_json::Value::String(s) => Some(crate::types::MessageContent::Text(s.clone())),
-                serde_json::Value::Array(parts) => {
-                    let mut parsed_parts = Vec::new();
-                    for part in parts {
-                        if let Some(part_type) = part["type"].as_str() {
-                            match part_type {
-                                "text" => {
-                                    if let Some(text) = part["text"].as_str() {
-                                        parsed_parts.push(crate::types::MessagePart::Text {
-                                            part_type: "text".to_string(),
-                                            text: text.to_string(),
-                                        });
-                                    }
-                                }
-                                "image_url" => {
-                                    if let Some(image_obj) = part["image_url"].as_object() {
-                                        if let Some(url) = image_obj.get("url").and_then(|v| v.as_str()) {
-                                            parsed_parts.push(crate::types::MessagePart::Image {
-                                                part_type: "image_url".to_string(),
-                                                image_url: crate::types::ImageContent {
-                                                    url: url.to_string(),
-                                                    detail: image_obj.get("detail").and_then(|v| v.as_str()).map(|s| s.to_string()),
-                                                },
-                                            });
-                                        }
-                                    }
-                                }
-                                unknown_type => {
-                                    console_warn!("Unknown OpenAI content part type in response: {}", unknown_type);
-                                }
-                            }
-                        }
-                    }
-                    Some(crate::types::MessageContent::Parts(parsed_parts))
-                }
-                _ => None
-            }
-        } else {
-            None
-        };
-        
-        let mut message = ChatMessage {
-            role: parse_role(&choice.message.role),
-            content: message_content,
-            name: None,
-            tool_calls: None,
-            tool_call_id: None,
-            refusal: choice.message.refusal.clone(),
-            is_streaming: false,
-            finish_reason: choice.finish_reason.clone(),
-            metadata: Default::default(),
-        };
-        
-        if let Some(tool_calls) = choice.message.tool_calls {
-            message.tool_calls = Some(tool_calls.into_iter().map(|tc| ToolCall {
-                id: tc.id,
-                tool_type: tc.tool_type,
-                function: crate::types::FunctionCall {
-                    name: tc.function.name,
-                    arguments: tc.function.arguments,
-                },
-            }).collect());
-        }
-        
-        message.refusal = choice.message.refusal;
-        message.finish_reason = choice.finish_reason;
-        
-        // is_streaming is set to false by default
-        
-        messages.push(message);
-    }
-    
-    Ok(ChatResponse {
-        id: response.id,
-        model: response.model,
-        messages: messages.clone(),
-        usage: response.usage.map(|u| Usage {
-            prompt_tokens: u.prompt_tokens,
-            completion_tokens: u.completion_tokens,
-            total_tokens: u.total_tokens,
-        }),
-        created: response.created,
-        provider: Provider::OpenAI,
-    })
-}
-
-fn parse_openai_responses_api(response: OpenAIResponsesResponse, messages: &mut Vec<ChatMessage>) -> Result<ChatResponse> {
-    for output in response.output {
-        // Parse content parts (could include text and images)
-        let mut parts = Vec::new();
-        
-        for content_part in &output.content {
-            match content_part.content_type.as_str() {
-                "text" | "input_text" | "output_text" => {
-                    if let Some(text) = &content_part.text {
-                        parts.push(crate::types::MessagePart::Text {
-                            part_type: "text".to_string(),
-                            text: text.clone(),
-                        });
-                    }
-                }
-                "image_url" => {
-                    if let Some(image_value) = &content_part.image_url {
-                        if let Some(image_obj) = image_value.as_object() {
-                            if let Some(url) = image_obj.get("url").and_then(|v| v.as_str()) {
-                                parts.push(crate::types::MessagePart::Image {
-                                    part_type: "image_url".to_string(),
-                                    image_url: crate::types::ImageContent {
-                                        url: url.to_string(),
-                                        detail: image_obj.get("detail").and_then(|v| v.as_str()).map(|s| s.to_string()),
-                                    },
-                                });
-                            }
-                        }
-                    }
-                }
-                unknown_type => {
-                    console_warn!("Unknown OpenAI Responses API content type: {}", unknown_type);
-                }
-            }
-        }
-        
-        let message_content = if parts.is_empty() {
-            None
-        } else if parts.len() == 1 && matches!(&parts[0], crate::types::MessagePart::Text { .. }) {
-            // Single text part - use simple text content
-            if let crate::types::MessagePart::Text { text, .. } = &parts[0] {
-                Some(crate::types::MessageContent::Text(text.clone()))
-            } else {
-                None
-            }
-        } else {
-            // Multiple parts or contains images
-            Some(crate::types::MessageContent::Parts(parts))
-        };
-        
-        let message = ChatMessage {
-            role: parse_role(&output.role),
-            content: message_content,
-            name: None,
-            tool_calls: None,
-            tool_call_id: None,
-            refusal: None,
-            is_streaming: false,
-            finish_reason: None,
-            metadata: Default::default(),
-        };
-        
-        messages.push(message);
-    }
-    
-    Ok(ChatResponse {
-        id: response.id,
-        model: response.model,
-        messages: messages.clone(),
-        usage: response.usage.map(|u| Usage {
-            prompt_tokens: u.input_tokens,
-            completion_tokens: u.output_tokens,
-            total_tokens: u.total_tokens,
-        }),
-        created: response.created_at,
-        provider: Provider::OpenAI,
-    })
-}
-
-fn parse_openai_streaming_response(response_str: &str, messages: &mut Vec<ChatMessage>) -> Result<ChatResponse> {
-    let mut combined_content = String::new();
-    let mut model = String::new();
-    let mut id = String::new();
-    
-    for line in response_str.lines() {
-        if line.starts_with("data: ") {
-            let data_str = &line[6..];
-            if data_str == "[DONE]" {
-                break;
-            }
-            
-            if let Ok(chunk) = serde_json::from_str::<Value>(data_str) {
-                if id.is_empty() {
-                    id = chunk["id"].as_str().unwrap_or("").to_string();
-                    model = chunk["model"].as_str().unwrap_or("").to_string();
-                }
-                
-                if let Some(choices) = chunk["choices"].as_array() {
-                    for choice in choices {
-                        if let Some(delta) = choice.get("delta") {
-                            if let Some(content) = delta["content"].as_str() {
-                                combined_content.push_str(content);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    
-    // Only stream if content is substantial
-    let should_stream = !combined_content.trim().is_empty() && combined_content.len() > 10;
-    let mut message = ChatMessage::assistant(combined_content);
-    message.is_streaming = should_stream;
-    messages.push(message);
-    
-    Ok(ChatResponse {
-        id,
-        model,
-        messages: messages.clone(),
-        usage: None,
-        created: None,
-        provider: Provider::OpenAI,
-    })
-}
-
-fn parse_anthropic_response(response_str: &str, messages: &mut Vec<ChatMessage>) -> Result<ChatResponse> {
-    // Check if this is a streaming response (SSE format)
-    if response_str.starts_with("event:") {
-        return parse_anthropic_streaming_response(response_str, messages);
-    }
-    
-    let response: AnthropicResponse = serde_json::from_str(response_str)
-        .with_context(|| format!("Failed to parse Anthropic response. Response preview: {}", 
-            &response_str[..response_str.len().min(200)]))?;
-    
-    // Collect text content
-    let text_content = response.content
-        .iter()
-        .filter_map(|c| c.text.as_ref())
-        .map(|s| s.as_str())
-        .collect::<Vec<_>>()
-        .join("");
-    
-    // Collect tool calls
-    let tool_calls: Vec<ToolCall> = response.content
-        .iter()
-        .filter(|c| c.content_type == "tool_use")
-        .filter_map(|c| {
-            match (c.id.as_ref(), c.name.as_ref(), c.input.as_ref()) {
-                (Some(id), Some(name), Some(input)) => {
-                    Some(ToolCall {
-                        id: id.clone(),
-                        tool_type: "function".to_string(),
-                        function: crate::types::FunctionCall {
-                            name: name.clone(),
-                            arguments: serde_json::to_string(input).unwrap_or_default(),
-                        },
-                    })
-                }
-                _ => None
-            }
-        })
-        .collect();
-    
-    let mut message = ChatMessage::assistant(text_content);
-    if !tool_calls.is_empty() {
-        message.tool_calls = Some(tool_calls);
-    }
-    
-    // Set finish reason from stop_reason
-    message.finish_reason = response.stop_reason.clone();
-    
-    messages.push(message);
-    
-    Ok(ChatResponse {
-        id: response.id,
-        model: response.model,
-        messages: messages.clone(),
-        usage: response.usage.map(|u| Usage {
-            prompt_tokens: u.input_tokens,
-            completion_tokens: u.output_tokens,
-            total_tokens: u.input_tokens.zip(u.output_tokens).map(|(i, o)| i + o),
-        }),
-        created: None,
-        provider: Provider::Anthropic,
-    })
-}
-
-fn parse_anthropic_streaming_response(response_str: &str, messages: &mut Vec<ChatMessage>) -> Result<ChatResponse> {
-    let mut combined_content = String::new();
-    let mut model = String::new();
-    let mut id = String::new();
-    let mut input_tokens = None;
-    let mut output_tokens = None;
-    
-    // Parse SSE format
-    for line in response_str.lines() {
-        if line.starts_with("data: ") {
-            let data_str = &line[6..];
-            if let Ok(data) = serde_json::from_str::<serde_json::Value>(data_str) {
-                // Extract model and ID from message_start
-                if data["type"] == "message_start" {
-                    if let Some(message) = data.get("message") {
-                        id = message["id"].as_str().unwrap_or("").to_string();
-                        model = message["model"].as_str().unwrap_or("").to_string();
-                        if let Some(usage) = message.get("usage") {
-                            input_tokens = usage["input_tokens"].as_i64().map(|x| x as i32);
-                            output_tokens = usage["output_tokens"].as_i64().map(|x| x as i32);
-                        }
-                    }
-                }
-                // Extract text from content_block_delta events
-                else if data["type"] == "content_block_delta" {
-                    if let Some(delta) = data.get("delta") {
-                        if let Some(text) = delta["text"].as_str() {
-                            combined_content.push_str(text);
-                        }
-                    }
-                }
-                // Extract final usage from message_delta
-                else if data["type"] == "message_delta" {
-                    if let Some(usage) = data.get("usage") {
-                        if let Some(output) = usage["output_tokens"].as_i64() {
-                            output_tokens = Some(output as i32);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    
-    // Only stream if content is substantial
-    let should_stream = !combined_content.trim().is_empty() && combined_content.len() > 10;
-    let mut message = ChatMessage::assistant(combined_content);
-    message.is_streaming = should_stream;
-    messages.push(message);
-    
-    Ok(ChatResponse {
-        id,
-        model,
-        messages: messages.clone(),
-        usage: if input_tokens.is_some() || output_tokens.is_some() {
-            Some(Usage {
-                prompt_tokens: input_tokens,
-                completion_tokens: output_tokens,
-                total_tokens: input_tokens.zip(output_tokens).map(|(i, o)| i + o),
-            })
-        } else {
-            None
-        },
-        created: None,
-        provider: Provider::Anthropic,
-    })
-}
-
-fn parse_google_response(response_str: &str, messages: &mut Vec<ChatMessage>) -> Result<ChatResponse> {
-    let response: Value = serde_json::from_str(response_str)
-        .context("Failed to parse Google response")?;
-    
-    if let Some(candidates) = response["candidates"].as_array() {
-        for candidate in candidates {
-            if let Some(content) = candidate.get("content") {
-                if let Some(parts) = content["parts"].as_array() {
-                    for part in parts {
-                        if let Some(text) = part["text"].as_str() {
-                            let message = ChatMessage::assistant(text.to_string());
-                            // is_streaming is set to false by default
-                            messages.push(message);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    
-    Ok(ChatResponse {
-        id: response["id"].as_str().unwrap_or("").to_string(),
-        model: response["model"].as_str().unwrap_or("").to_string(),
-        messages: messages.clone(),
-        usage: None,
-        created: None,
-        provider: Provider::Google,
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_multi_turn_cassette_parsing() {
-        let cassette_content = r#"interactions:
-- request:
-    body: '{"messages":[{"role":"user","content":"What is machine learning?"},{"role":"assistant","content":"Machine learning is a subset of artificial intelligence..."},{"role":"user","content":"Can you give me an example?"}],"model":"gpt-4o","max_completion_tokens":200}'
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: '{"id": "chatcmpl-test", "object": "chat.completion", "created": 1750105908, "model": "gpt-4o-2024-08-06", "choices": [{"index": 0, "message": {"role": "assistant", "content": "Certainly! One common example...", "refusal": null}, "finish_reason": "length"}], "usage": {"prompt_tokens": 36, "completion_tokens": 200, "total_tokens": 236}}'
-"#;
-
-        let result = parse_cassette(cassette_content).unwrap();
-        
-        println!("Parsed {} messages", result.messages.len());
-        for (i, msg) in result.messages.iter().enumerate() {
-            println!("Message {}: {:?} - {:?}", i, msg.role, msg.get_text_content());
-        }
-        
-        // Check we have all messages: 2 from request + 1 from response
-        assert_eq!(result.messages.len(), 4, "Should have 4 messages total: 3 from request + 1 from response");
-        
-        assert_eq!(result.messages[0].role, crate::types::MessageRole::User);
-        assert_eq!(result.messages[1].role, crate::types::MessageRole::Assistant); 
-        assert_eq!(result.messages[2].role, crate::types::MessageRole::User);
-        assert_eq!(result.messages[3].role, crate::types::MessageRole::Assistant);
-    }
-
-    #[test]
-    fn test_openai_responses_api_parsing() {
-        // Test parsing an OpenAI Responses API cassette (uses /v1/responses endpoint)
-        let responses_cassette = r#"interactions:
-- request:
-    body: '{"input":"Hello, how are you?","model":"gpt-4o"}'
-    uri: https://api.openai.com/v1/responses
-  response:
-    body:
-      string: '{"id": "resp_123", "model": "gpt-4o-2024-08-06", "output": [{"id": "msg_456", "type": "message", "content": [{"type": "output_text", "text": "Hello! I am just a program, so I do not have feelings, but I am here and ready to help."}], "role": "assistant"}], "usage": {"input_tokens": 13, "output_tokens": 29, "total_tokens": 42}}'
-"#;
-
-        let result = parse_cassette(responses_cassette).unwrap();
-        
-        println!("OpenAI Responses API parsed {} messages", result.messages.len());
-        for (i, msg) in result.messages.iter().enumerate() {
-            println!("Message {}: {:?} - {:?}", i, msg.role, msg.get_text_content());
-        }
-        
-        // Should have 1 message from request input + 1 from response output
-        assert_eq!(result.messages.len(), 2, "Should have 2 messages total");
-        
-        assert_eq!(result.messages[0].role, crate::types::MessageRole::User);
-        assert_eq!(result.messages[1].role, crate::types::MessageRole::Assistant);
-        
-        // Verify content is parsed correctly
-        assert_eq!(result.messages[0].get_text_content().unwrap(), "Hello, how are you?");
-        assert!(result.messages[1].get_text_content().unwrap().contains("Hello! I am just a program"));
-        
-        // Verify provider detection
-        assert_eq!(result.provider, crate::types::Provider::OpenAI);
-        
-        // Verify usage parsing
-        assert!(result.usage.is_some());
-        let usage = result.usage.unwrap();
-        assert_eq!(usage.prompt_tokens, Some(13));
-        assert_eq!(usage.completion_tokens, Some(29));
-        assert_eq!(usage.total_tokens, Some(42));
-    }
-
-    #[test]
-    fn test_real_multi_turn_cassette_file() {
-        let cassette_content = include_str!("../../samples/cassettes/openai_chat_completions/test_multi_turn_conversation.yaml");
-        
-        let result = parse_cassette(cassette_content).unwrap();
-        
-        println!("Real cassette parsed {} messages", result.messages.len());
-        for (i, msg) in result.messages.iter().enumerate() {
-            println!("Message {}: {:?} - {:?}", i, msg.role, msg.get_text_content().map(|s| s.chars().take(100).collect::<String>()));
-        }
-        
-        // Check we have all messages: 3 from request + 1 from response  
-        assert_eq!(result.messages.len(), 4, "Should have 4 messages total: 3 from request + 1 from response");
-        
-        assert_eq!(result.messages[0].role, crate::types::MessageRole::User);
-        assert_eq!(result.messages[1].role, crate::types::MessageRole::Assistant); 
-        assert_eq!(result.messages[2].role, crate::types::MessageRole::User);
-        assert_eq!(result.messages[3].role, crate::types::MessageRole::Assistant);
-        
-        // Verify content is parsed correctly
-        assert!(result.messages[0].get_text_content().unwrap().contains("What is machine learning?"));
-        assert!(result.messages[2].get_text_content().unwrap().contains("Can you give me an example?"));
-    }
-
-    #[test]
-    fn test_unknown_provider_handling() {
-        let cassette_content = r#"interactions:
-- request:
-    body: '{"messages":[{"role":"user","content":"Hello"}]}'
-    uri: https://unknown-llm-provider.com/v1/chat
-  response:
-    body:
-      string: '{"id": "test", "message": "Response from unknown provider"}'
-"#;
-
-        let result = parse_cassette(cassette_content).unwrap();
-        
-        // Should handle unknown provider gracefully
-        assert!(matches!(result.provider, crate::types::Provider::Unknown(_)));
-        // Unknown providers don't parse messages from the request body by default
-        assert_eq!(result.messages.len(), 0);
-    }
-
-    #[test]
-    fn test_unknown_content_types() {
-        // Test OpenAI with unknown content type
-        let cassette_content = r#"interactions:
-- request:
-    body: '{"messages":[{"role":"user","content":[{"type":"text","text":"Hello"},{"type":"audio","audio_url":"http://example.com/audio.mp3"}]}]}'
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: '{"id": "test", "model": "gpt-4", "choices": [{"message": {"role": "assistant", "content": "Hi there!"}}]}'
-"#;
-
-        let result = parse_cassette(cassette_content).unwrap();
-        
-        // Should parse successfully, ignoring unknown content type
-        assert_eq!(result.provider, crate::types::Provider::OpenAI);
-        assert_eq!(result.messages.len(), 2);
-        
-        // Check that the text part was parsed correctly
-        if let Some(crate::types::MessageContent::Parts(parts)) = &result.messages[0].content {
-            assert_eq!(parts.len(), 1); // Only text part should be parsed
-            assert!(matches!(&parts[0], crate::types::MessagePart::Text { text, .. } if text == "Hello"));
-        } else {
-            panic!("Expected Parts content");
-        }
-    }
-
-    #[test]
-    fn test_malformed_multimodal_content() {
-        // Test with malformed image content
-        let cassette_content = r#"interactions:
-- request:
-    body: '{"messages":[{"role":"user","content":[{"type":"text","text":"Look at this"},{"type":"image_url","image_url":{"bad_field":"no_url"}}]}]}'
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: '{"id": "test", "model": "gpt-4", "choices": [{"message": {"role": "assistant", "content": "I cannot see the image"}}]}'
-"#;
-
-        let result = parse_cassette(cassette_content).unwrap();
-        
-        // Should handle malformed image gracefully
-        assert_eq!(result.messages.len(), 2);
-        
-        // Only text should be parsed from the malformed multimodal content
-        if let Some(crate::types::MessageContent::Parts(parts)) = &result.messages[0].content {
-            assert_eq!(parts.len(), 1); // Only text part
-            assert!(matches!(&parts[0], crate::types::MessagePart::Text { text, .. } if text == "Look at this"));
-        } else {
-            panic!("Expected Parts content");
-        }
-    }
-
-    #[test]
-    fn test_empty_content_array() {
-        let cassette_content = r#"interactions:
-- request:
-    body: '{"messages":[{"role":"user","content":[]}]}'
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: '{"id": "test", "model": "gpt-4", "choices": [{"message": {"role": "assistant", "content": "Empty content?"}}]}'
-"#;
-
-        let result = parse_cassette(cassette_content).unwrap();
-        
-        // Should handle empty content array
-        assert_eq!(result.messages.len(), 2);
-        
-        // First message should have empty Parts
-        if let Some(crate::types::MessageContent::Parts(parts)) = &result.messages[0].content {
-            assert_eq!(parts.len(), 0);
-        } else {
-            panic!("Expected Parts content");
-        }
-    }
-
-    #[test]
-    fn test_openai_error_response() {
-        let cassette_content = r#"interactions:
-- request:
-    body: '{"messages":[{"role":"user","content":"Hello"}]}'
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    body:
-      string: '{"error": {"message": "Invalid API key", "type": "invalid_request_error", "param": null, "code": "invalid_api_key"}}'
-"#;
-
-        let result = parse_cassette(cassette_content).unwrap();
-        
-        // Should handle error response
-        assert_eq!(result.messages.len(), 2); // Request + error message
-        assert_eq!(result.messages[1].role, crate::types::MessageRole::System);
-        assert!(result.messages[1].get_text_content().unwrap().contains("Invalid API key"));
-    }
-
-    #[test]
-    fn test_anthropic_tool_use_parsing() {
-        let cassette_content = r#"interactions:
-- request:
-    body: '{"messages":[{"role":"user","content":"What is the weather in Tokyo?"}],"tools":[{"name":"get_weather","input_schema":{"type":"object"}}]}'
-    uri: https://api.anthropic.com/v1/messages
-  response:
-    body:
-      string: '{"id":"msg_123","type":"message","role":"assistant","model":"claude-3-sonnet-20240229","content":[{"type":"text","text":"I will check the weather for you."},{"type":"tool_use","id":"tool_123","name":"get_weather","input":{"location":"Tokyo"}}],"usage":{"input_tokens":100,"output_tokens":50}}'
-"#;
-
-        let result = parse_cassette(cassette_content).unwrap();
-        
-        // Should parse tool use correctly
-        assert_eq!(result.messages.len(), 2);
-        let assistant_msg = &result.messages[1];
-        assert_eq!(assistant_msg.role, crate::types::MessageRole::Assistant);
-        assert_eq!(assistant_msg.get_text_content().unwrap(), "I will check the weather for you.");
-        
-        // Check tool calls
-        assert!(assistant_msg.tool_calls.is_some());
-        let tool_calls = assistant_msg.tool_calls.as_ref().unwrap();
-        assert_eq!(tool_calls.len(), 1);
-        assert_eq!(tool_calls[0].id, "tool_123");
-        assert_eq!(tool_calls[0].function.name, "get_weather");
-        assert!(tool_calls[0].function.arguments.contains("Tokyo"));
-    }
-}
\ No newline at end of file
diff --git a/crates/chat-ui/src/utils/flexible_parser.rs b/crates/chat-ui/src/utils/flexible_parser.rs
deleted file mode 100644
index 071e9cfe..00000000
--- a/crates/chat-ui/src/utils/flexible_parser.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-use crate::parsers;
-use crate::types::ChatResponse;
-use crate::utils::cassette_loader;
-use anyhow::Result;
-
-/// Parse a cassette file using the new parsing architecture
-pub fn parse_cassette(json_content: &str) -> Result<ChatResponse> {
-    // Load the cassette as raw HTTP data
-    let interaction = cassette_loader::load_cassette(json_content)?;
-
-    // Parse the interaction into a chat response
-    parsers::parse_interaction(&interaction)
-}
diff --git a/crates/chat-ui/src/utils/markdown.rs b/crates/chat-ui/src/utils/markdown.rs
deleted file mode 100644
index 2652733a..00000000
--- a/crates/chat-ui/src/utils/markdown.rs
+++ /dev/null
@@ -1,136 +0,0 @@
-use yew::prelude::*;
-
-pub fn render_markdown(content: &str) -> Html {
-    // For now, let's do basic markdown rendering without the pulldown-cmark dependency
-    // to avoid version conflicts. We can enhance this later.
-    let mut html_output = String::new();
-    let mut in_code_block = false;
-    let mut code_content = String::new();
-
-    for line in content.lines() {
-        if line.starts_with("```") {
-            if in_code_block {
-                // End code block
-                html_output.push_str("<pre><code>");
-                html_output.push_str(&html_escape(&code_content));
-                html_output.push_str("</code></pre>");
-                code_content.clear();
-                in_code_block = false;
-            } else {
-                // Start code block
-                in_code_block = true;
-            }
-        } else if in_code_block {
-            if !code_content.is_empty() {
-                code_content.push('\n');
-            }
-            code_content.push_str(line);
-        } else {
-            // Simple replacements for basic markdown
-            let mut processed_line = line.to_string();
-
-            // Headers
-            if let Some(rest) = processed_line.strip_prefix("### ") {
-                html_output.push_str(&format!("<h3>{}</h3>", html_escape(rest)));
-            } else if let Some(rest) = processed_line.strip_prefix("## ") {
-                html_output.push_str(&format!("<h2>{}</h2>", html_escape(rest)));
-            } else if let Some(rest) = processed_line.strip_prefix("# ") {
-                html_output.push_str(&format!("<h1>{}</h1>", html_escape(rest)));
-            } else if processed_line.trim().is_empty() {
-                // Empty line
-                if !html_output.ends_with("</p>") && !html_output.ends_with("</pre>") {
-                    html_output.push_str("<br>");
-                }
-            } else {
-                // Regular paragraph
-                html_output.push_str("<p>");
-
-                // Bold text
-                processed_line = replace_pattern(&processed_line, "**", "<strong>", "</strong>");
-
-                // Italic text
-                processed_line = replace_pattern(&processed_line, "*", "<em>", "</em>");
-
-                // Inline code
-                processed_line = replace_inline_code(&processed_line);
-
-                html_output.push_str(&processed_line);
-                html_output.push_str("</p>");
-            }
-        }
-    }
-
-    // Handle unclosed code block
-    if in_code_block {
-        html_output.push_str("<pre><code>");
-        html_output.push_str(&html_escape(&code_content));
-        html_output.push_str("</code></pre>");
-    }
-
-    Html::from_html_unchecked(AttrValue::from(html_output))
-}
-
-fn replace_pattern(text: &str, delimiter: &str, open_tag: &str, close_tag: &str) -> String {
-    let parts: Vec<&str> = text.split(delimiter).collect();
-    if parts.len() < 3 {
-        return text.to_string();
-    }
-
-    let mut result = String::new();
-    let mut in_delimiter = false;
-
-    for (i, part) in parts.iter().enumerate() {
-        if i == 0 {
-            result.push_str(part);
-        } else if in_delimiter {
-            result.push_str(close_tag);
-            result.push_str(part);
-            in_delimiter = false;
-        } else {
-            result.push_str(open_tag);
-            result.push_str(part);
-            in_delimiter = true;
-        }
-    }
-
-    result
-}
-
-fn replace_inline_code(text: &str) -> String {
-    let parts: Vec<&str> = text.split('`').collect();
-    if parts.len() < 3 {
-        return text.to_string();
-    }
-
-    let mut result = String::new();
-    let mut in_code = false;
-
-    for (i, part) in parts.iter().enumerate() {
-        if i == 0 {
-            result.push_str(part);
-        } else if in_code {
-            result.push_str("</code>");
-            result.push_str(part);
-            in_code = false;
-        } else {
-            result.push_str("<code>");
-            result.push_str(&html_escape(part));
-            in_code = true;
-        }
-    }
-
-    result
-}
-
-fn html_escape(s: &str) -> String {
-    s.chars()
-        .map(|c| match c {
-            '&' => "&amp;".to_string(),
-            '<' => "&lt;".to_string(),
-            '>' => "&gt;".to_string(),
-            '"' => "&quot;".to_string(),
-            '\'' => "&#39;".to_string(),
-            _ => c.to_string(),
-        })
-        .collect()
-}
diff --git a/crates/chat-ui/src/utils/mod.rs b/crates/chat-ui/src/utils/mod.rs
deleted file mode 100644
index c1ef0aac..00000000
--- a/crates/chat-ui/src/utils/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-pub mod cassette_loader;
-pub mod flexible_parser;
-pub mod markdown;
-pub mod simple_cassette_parser;
diff --git a/crates/chat-ui/src/utils/simple_cassette_parser.rs b/crates/chat-ui/src/utils/simple_cassette_parser.rs
deleted file mode 100644
index fee1bb1e..00000000
--- a/crates/chat-ui/src/utils/simple_cassette_parser.rs
+++ /dev/null
@@ -1,371 +0,0 @@
-use crate::types::{ChatMessage, ChatResponse, Provider};
-use anyhow::{Context, Result};
-use serde::Deserialize;
-use serde_json::{Value, json};
-use std::collections::HashMap;
-
-#[derive(Debug, Deserialize)]
-struct CassetteFile {
-    interactions: Vec<Interaction>,
-}
-
-#[derive(Debug, Deserialize)]
-struct Interaction {
-    request: Request,
-    response: Response,
-}
-
-#[derive(Debug, Deserialize)]
-struct Request {
-    body: String,
-    uri: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct Response {
-    body: ResponseBody,
-}
-
-#[derive(Debug, Deserialize)]
-struct ResponseBody {
-    string: String,
-}
-
-/// Parse a cassette file into a ChatResponse
-pub fn parse_cassette(json_content: &str) -> Result<ChatResponse> {
-    let cassette: CassetteFile =
-        serde_json::from_str(json_content).context("Failed to parse cassette JSON")?;
-
-    if cassette.interactions.is_empty() {
-        anyhow::bail!("No interactions found in cassette");
-    }
-
-    let interaction = &cassette.interactions[0];
-    let provider = Provider::from_uri(&interaction.request.uri);
-
-    // Parse request to get the messages
-    let request_body: Value =
-        serde_json::from_str(&interaction.request.body).context("Failed to parse request body")?;
-
-    let mut messages = extract_request_messages(&request_body, &provider)?;
-
-    // Parse response and determine if it's streaming
-    let is_streaming = interaction.response.body.string.starts_with("data:")
-        || interaction.response.body.string.starts_with("event:");
-
-    // Parse response and add assistant message
-    if is_streaming {
-        parse_streaming_response(&interaction.response.body.string, &mut messages)?;
-    } else {
-        parse_json_response(&interaction.response.body.string, &mut messages, &provider)?;
-    }
-
-    // Extract model and id from response if available
-    let (id, model) = if !is_streaming {
-        if let Ok(resp) = serde_json::from_str::<Value>(&interaction.response.body.string) {
-            (
-                resp.get("id")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or("unknown")
-                    .to_string(),
-                resp.get("model")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or("unknown")
-                    .to_string(),
-            )
-        } else {
-            ("unknown".to_string(), "unknown".to_string())
-        }
-    } else {
-        // For streaming, extract from first data chunk
-        extract_streaming_metadata(&interaction.response.body.string)
-            .unwrap_or(("unknown".to_string(), "unknown".to_string()))
-    };
-
-    Ok(ChatResponse {
-        id,
-        model,
-        messages,
-        provider,
-        usage: None,
-        metadata: Default::default(),
-    })
-}
-
-/// Extract messages from request body
-fn extract_request_messages(
-    request_body: &Value,
-    _provider: &Provider,
-) -> Result<Vec<ChatMessage>> {
-    let mut messages = Vec::new();
-
-    // Handle different request formats
-    if let Some(msgs_array) = request_body.get("messages").and_then(|v| v.as_array()) {
-        // Standard messages array format (OpenAI, Anthropic)
-        for msg in msgs_array {
-            let role = msg
-                .get("role")
-                .and_then(|v| v.as_str())
-                .unwrap_or("user")
-                .to_string();
-
-            let content = msg.get("content").cloned();
-
-            let mut metadata = HashMap::new();
-
-            // Store other fields in metadata
-            if let Some(name) = msg.get("name") {
-                metadata.insert("name".to_string(), name.clone());
-            }
-            if let Some(tool_calls) = msg.get("tool_calls") {
-                metadata.insert("tool_calls".to_string(), tool_calls.clone());
-            }
-
-            messages.push(ChatMessage {
-                role,
-                content,
-                tool_calls: None,
-                name: None,
-                metadata,
-            });
-        }
-    } else if let Some(input) = request_body.get("input").and_then(|v| v.as_str()) {
-        // OpenAI Responses API format
-        messages.push(ChatMessage {
-            role: "user".to_string(),
-            content: Some(Value::String(input.to_string())),
-            tool_calls: None,
-            name: None,
-            metadata: Default::default(),
-        });
-    } else if let Some(contents) = request_body.get("contents").and_then(|v| v.as_array()) {
-        // Google format
-        for content in contents {
-            let role = content
-                .get("role")
-                .and_then(|v| v.as_str())
-                .unwrap_or("user")
-                .to_string();
-
-            if let Some(parts) = content.get("parts").and_then(|v| v.as_array()) {
-                for part in parts {
-                    if let Some(text) = part.get("text").and_then(|v| v.as_str()) {
-                        messages.push(ChatMessage {
-                            role: role.clone(),
-                            content: Some(Value::String(text.to_string())),
-                            tool_calls: None,
-                            name: None,
-                            metadata: Default::default(),
-                        });
-                    }
-                }
-            }
-        }
-    }
-
-    Ok(messages)
-}
-
-/// Parse streaming response (SSE format)
-fn parse_streaming_response(response_str: &str, messages: &mut Vec<ChatMessage>) -> Result<()> {
-    let mut combined_content = String::new();
-    let mut role = "assistant".to_string();
-
-    for line in response_str.lines() {
-        if let Some(data_str) = line.strip_prefix("data: ") {
-            if data_str == "[DONE]" {
-                break;
-            }
-
-            if let Ok(chunk) = serde_json::from_str::<Value>(data_str) {
-                // Extract role if present
-                if let Some(choices) = chunk.get("choices").and_then(|v| v.as_array())
-                    && let Some(choice) = choices.first()
-                    && let Some(delta) = choice.get("delta")
-                {
-                    if let Some(r) = delta.get("role").and_then(|v| v.as_str()) {
-                        role = r.to_string();
-                    }
-                    if let Some(content) = delta.get("content").and_then(|v| v.as_str()) {
-                        combined_content.push_str(content);
-                    }
-                }
-
-                // Handle Anthropic streaming format
-                if chunk.get("type").and_then(|v| v.as_str()) == Some("content_block_delta")
-                    && let Some(text) = chunk
-                        .get("delta")
-                        .and_then(|d| d.get("text"))
-                        .and_then(|t| t.as_str())
-                {
-                    combined_content.push_str(text);
-                }
-            }
-        }
-    }
-
-    if !combined_content.is_empty() {
-        let mut metadata = HashMap::new();
-        metadata.insert("is_streaming".to_string(), json!(true));
-
-        messages.push(ChatMessage {
-            role,
-            content: Some(Value::String(combined_content)),
-            tool_calls: None,
-            name: None,
-            metadata,
-        });
-    }
-
-    Ok(())
-}
-
-/// Parse JSON response
-fn parse_json_response(
-    response_str: &str,
-    messages: &mut Vec<ChatMessage>,
-    provider: &Provider,
-) -> Result<()> {
-    let response: Value =
-        serde_json::from_str(response_str).context("Failed to parse response JSON")?;
-
-    match provider {
-        Provider::OpenAI => {
-            // Handle both Chat Completions and Responses API
-            if let Some(choices) = response.get("choices").and_then(|v| v.as_array()) {
-                // Chat Completions API
-                for choice in choices {
-                    if let Some(message) = choice.get("message") {
-                        parse_message_object(message, messages)?;
-                    }
-                }
-            } else if let Some(outputs) = response.get("output").and_then(|v| v.as_array()) {
-                // Responses API
-                for output in outputs {
-                    parse_message_object(output, messages)?;
-                }
-            }
-        }
-        Provider::Anthropic => {
-            // Anthropic messages API
-            if let Some(content_array) = response.get("content").and_then(|v| v.as_array()) {
-                let mut text_parts = Vec::new();
-                let mut metadata = HashMap::new();
-
-                for content in content_array {
-                    if let Some(content_type) = content.get("type").and_then(|v| v.as_str()) {
-                        match content_type {
-                            "text" => {
-                                if let Some(text) = content.get("text").and_then(|v| v.as_str()) {
-                                    text_parts.push(text);
-                                }
-                            }
-                            "tool_use" => {
-                                // Store tool use in metadata
-                                metadata.insert("tool_use".to_string(), content.clone());
-                            }
-                            _ => {}
-                        }
-                    }
-                }
-
-                if !text_parts.is_empty() || !metadata.is_empty() {
-                    messages.push(ChatMessage {
-                        role: "assistant".to_string(),
-                        content: Some(Value::String(text_parts.join(""))),
-                        tool_calls: None,
-                        name: None,
-                        metadata,
-                    });
-                }
-            }
-        }
-        Provider::Google => {
-            // Google Gemini API
-            if let Some(candidates) = response.get("candidates").and_then(|v| v.as_array()) {
-                for candidate in candidates {
-                    if let Some(content) = candidate.get("content")
-                        && let Some(parts) = content.get("parts").and_then(|v| v.as_array())
-                    {
-                        for part in parts {
-                            if let Some(text) = part.get("text").and_then(|v| v.as_str()) {
-                                messages.push(ChatMessage {
-                                    role: "assistant".to_string(),
-                                    content: Some(Value::String(text.to_string())),
-                                    tool_calls: None,
-                                    name: None,
-                                    metadata: Default::default(),
-                                });
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        _ => {
-            // Unknown provider - try to extract a reasonable response
-            if let Some(text) = response.get("text").and_then(|v| v.as_str()) {
-                messages.push(ChatMessage::assistant(text));
-            }
-        }
-    }
-
-    Ok(())
-}
-
-/// Parse a message object into a ChatMessage
-fn parse_message_object(message: &Value, messages: &mut Vec<ChatMessage>) -> Result<()> {
-    let role = message
-        .get("role")
-        .and_then(|v| v.as_str())
-        .unwrap_or("assistant")
-        .to_string();
-
-    let content = message.get("content").cloned();
-
-    let mut metadata = HashMap::new();
-
-    // Store additional fields in metadata
-    if let Some(refusal) = message.get("refusal") {
-        metadata.insert("refusal".to_string(), refusal.clone());
-    }
-    if let Some(finish_reason) = message.get("finish_reason") {
-        metadata.insert("finish_reason".to_string(), finish_reason.clone());
-    }
-    if let Some(tool_calls) = message.get("tool_calls") {
-        metadata.insert("tool_calls".to_string(), tool_calls.clone());
-    }
-
-    messages.push(ChatMessage {
-        role,
-        content,
-        tool_calls: None,
-        name: None,
-        metadata,
-    });
-
-    Ok(())
-}
-
-/// Extract metadata from streaming response
-fn extract_streaming_metadata(response_str: &str) -> Option<(String, String)> {
-    for line in response_str.lines() {
-        if let Some(data_str) = line.strip_prefix("data: ")
-            && data_str != "[DONE]"
-            && let Ok(chunk) = serde_json::from_str::<Value>(data_str)
-        {
-            let id = chunk
-                .get("id")
-                .and_then(|v| v.as_str())
-                .unwrap_or("unknown")
-                .to_string();
-            let model = chunk
-                .get("model")
-                .and_then(|v| v.as_str())
-                .unwrap_or("unknown")
-                .to_string();
-            return Some((id, model));
-        }
-    }
-    None
-}
diff --git a/crates/core/Cargo.toml b/crates/core/Cargo.toml
deleted file mode 100644
index 8d464f23..00000000
--- a/crates/core/Cargo.toml
+++ /dev/null
@@ -1,60 +0,0 @@
-[package]
-name = "gate-core"
-version.workspace = true
-edition.workspace = true
-authors.workspace = true
-license.workspace = true
-repository.workspace = true
-keywords.workspace = true
-categories.workspace = true
-
-[features]
-default = ["router"]
-cloudflare = ["dep:worker", "dep:sqlx-d1"]
-tests = ["dep:uuid"]
-router = ["dep:uuid", "dep:async-stream", "dep:rand", "dep:js-sys", "tracing"]
-tracing = ["dep:tracing", "dep:hex", "dep:getrandom", "dep:rand"]
-tracing-otlp = ["tracing", "dep:opentelemetry", "dep:opentelemetry-otlp", "dep:opentelemetry_sdk", "dep:tracing-opentelemetry", "dep:tracing-subscriber"]
-tracing-prometheus = ["tracing"]
-
-[dependencies]
-anyhow.workspace = true
-async-stream = { version = "0.3", optional = true }
-async-trait.workspace = true
-chrono.workspace = true
-config.workspace = true
-futures.workspace = true
-http.workspace = true
-rand = { version = "0.9", optional = true }
-rust_decimal = { version = "1.42", features = ["serde"] }
-serde.workspace = true
-serde_json.workspace = true
-sqlx-d1 = { version = "0.2.1", optional = true }
-thiserror.workspace = true
-tokio = { workspace = true, features = ["sync", "time"] }
-url.workspace = true
-uuid = { workspace = true, features = ["v4", "serde"], optional = true }
-
-# Optional dependencies for cloudflare feature
-worker = { version = "0.6", optional = true }
-
-# Optional dependencies for tracing feature
-tracing = { workspace = true, optional = true }
-hex = { workspace = true, optional = true }
-
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-getrandom = { workspace = true, features = ["wasm_js"], optional = true }
-js-sys = { version = "0.3", optional = true }
-
-# Optional dependencies for tracing-otlp feature (native only)
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-opentelemetry = { version = "0.32", default-features = false, features = ["trace"], optional = true }
-opentelemetry-otlp = { version = "0.32", default-features = false, features = ["trace", "http-proto", "reqwest-blocking-client"], optional = true }
-opentelemetry_sdk = { version = "0.32", default-features = false, features = ["trace", "rt-tokio"], optional = true }
-tracing-opentelemetry = { version = "0.33", default-features = false, optional = true }
-tracing-subscriber = { workspace = true, optional = true }
-
-[dev-dependencies]
-mockall.workspace = true
-tokio = { workspace = true, features = ["test-util", "macros", "rt-multi-thread"] }
-uuid = { workspace = true, features = ["v4"] }
diff --git a/crates/core/README.md b/crates/core/README.md
deleted file mode 100644
index 21afa66f..00000000
--- a/crates/core/README.md
+++ /dev/null
@@ -1,63 +0,0 @@
-# gate-core
-
-Core abstractions and types for Gate. Defines the trait-based architecture that enables Gate's extensibility across native and WASM environments.
-
-## Responsibilities
-
-- **StateBackend trait**: Abstraction for persistent storage (users, API keys, usage tracking)
-- **Plugin system**: `GatePlugin` trait and hook registry for extending functionality
-- **Common types**: Shared data structures (User, ApiKey, Provider, Model, etc.)
-- **Error handling**: Unified error type with proper `#[from]` conversions
-- **WebAuthn**: Hardware authentication support
-
-## Key Traits
-
-### StateBackend
-```rust
-#[async_trait]
-pub trait StateBackend: Send + Sync {
-    async fn get_api_key(&self, key_hash: &str) -> Result<Option<ApiKey>>;
-    async fn record_usage(&self, usage: &UsageRecord) -> Result<()>;
-    // User, organization, provider, model management
-}
-```
-
-### GatePlugin
-```rust
-#[async_trait]
-pub trait GatePlugin: Send + Sync {
-    fn name(&self) -> &str;
-    async fn init(&mut self, context: PluginContext) -> Result<()>;
-}
-```
-
-## Features
-
-- `default`: Core functionality only
-- `cloudflare`: Adds `worker` and `sqlx-d1` for Cloudflare Workers
-- `tests`: Exposes test utilities and mocks
-
-## Usage
-
-Implement `StateBackend` for custom storage:
-```rust
-#[async_trait]
-impl StateBackend for MyStorage {
-    // Required method implementations
-}
-```
-
-Create plugins by implementing `GatePlugin` and registering hooks during `init()`.
-
-## Dependencies
-
-Minimal set:
-- `async-trait`, `thiserror` (required for trait system)
-- `serde`, `chrono`, `http` (data types)
-- `tokio` (sync primitives only, no runtime)
-
-## Risks
-
-- **WASM compatibility**: All code must work in both native and WASM targets
-- **No panics**: Never use `unwrap()` or `expect()` - this is library code
-- **Trait changes**: Breaking changes here affect entire ecosystem
\ No newline at end of file
diff --git a/crates/core/src/access/identity.rs b/crates/core/src/access/identity.rs
deleted file mode 100644
index 94371d0a..00000000
--- a/crates/core/src/access/identity.rs
+++ /dev/null
@@ -1,230 +0,0 @@
-use async_trait::async_trait;
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::fmt::{self, Display};
-use std::ops::Deref;
-use thiserror::Error;
-
-/// Identity of the subject performing an action
-#[derive(Debug, Clone)]
-pub struct SubjectIdentity<C: IdentityContext> {
-    pub id: String,
-    pub source: String,
-    pub context: C,
-}
-
-impl<C: IdentityContext> SubjectIdentity<C> {
-    pub fn new(id: impl Into<String>, source: impl Into<String>, context: C) -> Self {
-        Self {
-            id: id.into(),
-            source: source.into(),
-            context,
-        }
-    }
-}
-
-/// Context information for an identity
-pub trait IdentityContext: Send + Sync + Clone + std::fmt::Debug {
-    /// Serialize context to key-value pairs
-    fn to_attributes(&self) -> HashMap<String, String>;
-
-    /// Get a specific attribute value
-    fn get(&self, key: &str) -> Option<&str>;
-}
-
-/// Namespace for target objects
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub enum TargetNamespace {
-    System,
-    Local,
-    Organization(String),
-    Node(String),
-}
-
-impl Display for TargetNamespace {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::System => write!(f, "system"),
-            Self::Local => write!(f, "local"),
-            Self::Organization(org) => write!(f, "org:{org}"),
-            Self::Node(node) => write!(f, "node:{node}"),
-        }
-    }
-}
-
-/// Type of object being accessed
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub enum ObjectKind {
-    Model,
-    Provider,
-    User,
-    Users,
-    Config,
-    Billing,
-    System,
-    Quota,
-}
-
-impl Display for ObjectKind {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{self:?}")
-    }
-}
-
-/// Unique identifier for an object
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub struct ObjectId(String);
-
-impl ObjectId {
-    pub fn new(id: impl Into<String>) -> Self {
-        Self(id.into())
-    }
-}
-
-impl Deref for ObjectId {
-    type Target = str;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl From<&str> for ObjectId {
-    fn from(s: &str) -> Self {
-        Self(s.to_string())
-    }
-}
-
-impl From<String> for ObjectId {
-    fn from(s: String) -> Self {
-        Self(s)
-    }
-}
-
-impl Display for ObjectId {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-/// Identity of the object being accessed
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ObjectIdentity {
-    pub namespace: TargetNamespace,
-    pub kind: ObjectKind,
-    pub id: ObjectId,
-}
-
-impl ObjectIdentity {
-    pub fn local_model(model_id: impl Into<String>) -> Self {
-        Self {
-            namespace: TargetNamespace::Local,
-            kind: ObjectKind::Model,
-            id: ObjectId::new(model_id),
-        }
-    }
-
-    pub fn org_model(org: impl Into<String>, model_id: impl Into<String>) -> Self {
-        Self {
-            namespace: TargetNamespace::Organization(org.into()),
-            kind: ObjectKind::Model,
-            id: ObjectId::new(model_id),
-        }
-    }
-
-    pub fn local_provider(provider_id: impl Into<String>) -> Self {
-        Self {
-            namespace: TargetNamespace::Local,
-            kind: ObjectKind::Provider,
-            id: ObjectId::new(provider_id),
-        }
-    }
-
-    pub fn quota(user_id: impl Into<String>) -> Self {
-        Self {
-            namespace: TargetNamespace::Local,
-            kind: ObjectKind::Quota,
-            id: ObjectId::new(user_id),
-        }
-    }
-
-    pub fn wildcard() -> Self {
-        Self {
-            namespace: TargetNamespace::Local,
-            kind: ObjectKind::System,
-            id: ObjectId::new("*"),
-        }
-    }
-
-    /// Parse an object identity from a string format "namespace/kind/id"
-    pub fn from_string(s: &str) -> Result<Self, String> {
-        let parts: Vec<&str> = s.split('/').collect();
-        if parts.len() != 3 {
-            return Err(format!(
-                "Invalid object format: expected namespace/kind/id, got {s}"
-            ));
-        }
-
-        let namespace = match parts[0] {
-            "system" => TargetNamespace::System,
-            "local" => TargetNamespace::Local,
-            ns if ns.starts_with("org:") => {
-                TargetNamespace::Organization(ns.strip_prefix("org:").unwrap().to_string())
-            }
-            ns if ns.starts_with("node:") => {
-                TargetNamespace::Node(ns.strip_prefix("node:").unwrap().to_string())
-            }
-            _ => return Err(format!("Invalid namespace: {}", parts[0])),
-        };
-
-        let kind = match parts[1] {
-            "Model" => ObjectKind::Model,
-            "Provider" => ObjectKind::Provider,
-            "User" => ObjectKind::User,
-            "Users" => ObjectKind::Users,
-            "Config" => ObjectKind::Config,
-            "Billing" => ObjectKind::Billing,
-            "System" => ObjectKind::System,
-            "Quota" => ObjectKind::Quota,
-            _ => return Err(format!("Invalid object kind: {}", parts[1])),
-        };
-
-        Ok(Self {
-            namespace,
-            kind,
-            id: ObjectId::new(parts[2]),
-        })
-    }
-}
-
-impl Display for ObjectIdentity {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}/{}/{}", self.namespace, self.kind, self.id)
-    }
-}
-
-#[derive(Debug, Error)]
-pub enum AuthenticationError {
-    #[error("Invalid credentials")]
-    InvalidCredentials,
-
-    #[error("Authentication failed: {0}")]
-    Failed(String),
-
-    #[error("Token expired")]
-    TokenExpired,
-
-    #[error("Internal error: {0}")]
-    Internal(String),
-}
-
-/// Establishes identity from credentials
-#[async_trait]
-pub trait Authentication: Send + Sync {
-    type Context: IdentityContext;
-
-    async fn authenticate(
-        &self,
-        credentials: &serde_json::Value,
-    ) -> Result<SubjectIdentity<Self::Context>, AuthenticationError>;
-}
diff --git a/crates/core/src/access/mod.rs b/crates/core/src/access/mod.rs
deleted file mode 100644
index 5177a31b..00000000
--- a/crates/core/src/access/mod.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-pub mod identity;
-pub mod permissions;
-pub mod policies;
-
-pub use identity::{
-    Authentication, AuthenticationError, IdentityContext, ObjectId, ObjectIdentity, ObjectKind,
-    SubjectIdentity, TargetNamespace,
-};
-pub use permissions::{Action, PermissionDenied, PermissionManager, PermissionResult, Permissions};
-pub use policies::{PolicyDecision, PolicyLimit};
diff --git a/crates/core/src/access/permissions.rs b/crates/core/src/access/permissions.rs
deleted file mode 100644
index d1536476..00000000
--- a/crates/core/src/access/permissions.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-use super::identity::{IdentityContext, ObjectIdentity, SubjectIdentity};
-use async_trait::async_trait;
-use serde::{Deserialize, Serialize};
-use std::time::Duration;
-use thiserror::Error;
-
-/// Actions that can be performed on objects
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub enum Action {
-    Read,
-    Write,
-    Delete,
-    Execute,
-    Manage,
-    GrantPermission,
-    RevokePermission,
-    ViewPermissions,
-    ViewQuota,
-    UpdateQuota,
-    ConsumeQuota,
-}
-
-/// Reasons for permission denial
-#[derive(Debug, Clone, Error)]
-pub enum PermissionDenied {
-    #[error("Not authorized")]
-    NotAuthorized,
-
-    #[error("Permission expired")]
-    Expired,
-
-    #[error("Rate limited, retry after {retry_after:?}")]
-    RateLimited { retry_after: Duration },
-
-    #[error("Quota exceeded for {resource}")]
-    QuotaExceeded { resource: String },
-
-    #[error("Account suspended: {reason}")]
-    Suspended { reason: String },
-
-    #[error("Permission denied: {0}")]
-    Custom(String),
-}
-
-pub type PermissionResult = Result<(), PermissionDenied>;
-
-/// Checks if a subject can perform an action on an object
-#[async_trait]
-pub trait Permissions<C: IdentityContext>: Send + Sync {
-    async fn check(
-        &self,
-        subject: &SubjectIdentity<C>,
-        action: Action,
-        object: &ObjectIdentity,
-    ) -> PermissionResult;
-}
-
-/// Manages permission grants and revocations
-#[async_trait]
-pub trait PermissionManager<C: IdentityContext>: Permissions<C> {
-    /// Grant a permission to a subject
-    async fn grant(
-        &self,
-        granter: &SubjectIdentity<C>,
-        grantee: &SubjectIdentity<C>,
-        action: Action,
-        object: &ObjectIdentity,
-    ) -> PermissionResult;
-
-    /// Revoke a permission from a subject
-    async fn revoke(
-        &self,
-        revoker: &SubjectIdentity<C>,
-        subject: &SubjectIdentity<C>,
-        action: Action,
-        object: &ObjectIdentity,
-    ) -> PermissionResult;
-
-    /// Store a permission without checking granter's permissions
-    async fn store_permission_unchecked(
-        &self,
-        subject_id: &str,
-        action: Action,
-        object: &ObjectIdentity,
-    ) -> Result<(), PermissionDenied>;
-}
diff --git a/crates/core/src/access/policies.rs b/crates/core/src/access/policies.rs
deleted file mode 100644
index 59e6e301..00000000
--- a/crates/core/src/access/policies.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-use super::identity::{IdentityContext, ObjectIdentity, SubjectIdentity};
-use async_trait::async_trait;
-use rust_decimal::Decimal;
-use serde::{Deserialize, Serialize};
-use thiserror::Error;
-
-/// Limits that can be applied to allowed actions
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum PolicyLimit {
-    TokenLimit(usize),
-    RateLimit { per_minute: u32 },
-    CreditCost(Decimal),
-    Custom(String, serde_json::Value),
-}
-
-/// Result of a policy evaluation
-#[derive(Debug, Clone)]
-pub enum PolicyDecision {
-    Allow(Vec<PolicyLimit>),
-    Deny(String),
-}
-
-#[derive(Debug, Error)]
-pub enum PolicyError {
-    #[error("Policy evaluation failed: {0}")]
-    EvaluationFailed(String),
-
-    #[error("Internal error: {0}")]
-    Internal(String),
-}
-
-/// Generic inference request for policy checking
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct InferenceRequest {
-    pub model: String,
-    pub prompt: String,
-    pub max_tokens: Option<usize>,
-    pub temperature: Option<f32>,
-    pub has_images: bool,
-}
-
-/// Policy for inference operations
-#[async_trait]
-pub trait InferencePolicy<C: IdentityContext>: Send + Sync {
-    async fn check_inference(
-        &self,
-        subject: &SubjectIdentity<C>,
-        object: &ObjectIdentity,
-        request: &InferenceRequest,
-    ) -> Result<PolicyDecision, PolicyError>;
-}
diff --git a/crates/core/src/context.rs b/crates/core/src/context.rs
deleted file mode 100644
index e10519d5..00000000
--- a/crates/core/src/context.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use async_trait::async_trait;
-use std::collections::HashMap;
-
-/// Platform-agnostic request context trait
-///
-/// This trait abstracts away platform-specific details like Cloudflare's worker::Env
-/// to allow the same business logic to run on different platforms.
-#[async_trait]
-pub trait RequestContext: Send + Sync {
-    /// Get an environment variable
-    async fn get_env_var(&self, key: &str) -> Option<String>;
-
-    /// Get a secret value
-    async fn get_secret(&self, key: &str) -> Option<String>;
-
-    /// Get request headers
-    fn get_headers(&self) -> &HashMap<String, String>;
-
-    /// Get the request URL
-    fn get_url(&self) -> &str;
-
-    /// Get the request method
-    fn get_method(&self) -> &str;
-
-    /// Get the request body as bytes
-    async fn get_body(&self) -> Result<Vec<u8>, Box<dyn std::error::Error + Send + Sync>>;
-
-    /// Get client IP address
-    fn get_client_ip(&self) -> Option<String>;
-}
diff --git a/crates/core/src/errors.rs b/crates/core/src/errors.rs
deleted file mode 100644
index f7de6201..00000000
--- a/crates/core/src/errors.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum Error {
-    #[error("User not found: {0}")]
-    UserNotFound(String),
-
-    #[error("API key not found")]
-    ApiKeyNotFound,
-
-    #[error("Invalid API key")]
-    InvalidApiKey,
-
-    #[error("Provider not found: {0}")]
-    ProviderNotFound(String),
-
-    #[error("Model not found: {0}")]
-    ModelNotFound(String),
-
-    #[error("Insufficient permissions")]
-    Unauthorized,
-
-    #[error("Request rejected: {0}")]
-    Rejected(http::StatusCode, String),
-
-    #[error("Redirect required: {0}")]
-    Redirect(String),
-
-    #[error("State backend error: {0}")]
-    StateError(String),
-
-    #[error("Plugin error: {0}")]
-    PluginError(String),
-
-    #[error("Serialization error: {0}")]
-    SerializationError(#[from] serde_json::Error),
-
-    #[error("IO error: {0}")]
-    IoError(#[from] std::io::Error),
-
-    #[error("Internal error: {0}")]
-    Internal(String),
-
-    // Router-specific errors
-    #[error("No sinks available for routing")]
-    NoSinksAvailable,
-
-    #[error("Protocol conversion not supported: {0} to {1}")]
-    UnsupportedConversion(String, String),
-
-    #[error("Quota exceeded: {0}")]
-    QuotaExceeded(String),
-
-    #[error("All routes failed")]
-    AllRoutesFailed,
-
-    #[error("Model not supported by any sink: {0}")]
-    ModelNotSupported(String),
-
-    #[error("Invalid routing configuration: {0}")]
-    InvalidRoutingConfig(String),
-
-    #[error("Invalid request: {0}")]
-    InvalidRequest(String),
-
-    #[error("Service unavailable: {0}")]
-    ServiceUnavailable(String),
-
-    #[error("Invalid configuration: {0}")]
-    InvalidConfig(String),
-}
-
-pub type Result<T> = std::result::Result<T, Error>;
-
-// Cloudflare-specific error conversions
-#[cfg(feature = "cloudflare")]
-mod cloudflare_impls {
-    use super::Error;
-
-    impl From<worker::Error> for Error {
-        fn from(err: worker::Error) -> Self {
-            Error::StateError(format!("Worker error: {err}"))
-        }
-    }
-
-    impl From<worker::kv::KvError> for Error {
-        fn from(err: worker::kv::KvError) -> Self {
-            Error::StateError(format!("KV error: {err}"))
-        }
-    }
-
-    impl From<worker::d1::D1Error> for Error {
-        fn from(err: worker::d1::D1Error) -> Self {
-            Error::StateError(format!("D1 error: {err}"))
-        }
-    }
-
-    impl From<sqlx_d1::Error> for Error {
-        fn from(err: sqlx_d1::Error) -> Self {
-            Error::StateError(format!("D1 error: {err}"))
-        }
-    }
-}
diff --git a/crates/core/src/inference.rs b/crates/core/src/inference.rs
deleted file mode 100644
index 26a9af64..00000000
--- a/crates/core/src/inference.rs
+++ /dev/null
@@ -1,159 +0,0 @@
-use crate::Result;
-use async_trait::async_trait;
-use futures::stream::Stream;
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-use std::pin::Pin;
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ChatCompletionRequest {
-    pub model: String,
-    pub messages: Vec<ChatMessage>,
-    pub max_tokens: Option<u32>,
-    pub temperature: Option<f32>,
-    pub top_p: Option<f32>,
-    pub stream: Option<bool>,
-    pub stop: Option<Vec<String>>,
-    pub presence_penalty: Option<f32>,
-    pub frequency_penalty: Option<f32>,
-    pub logit_bias: Option<Value>,
-    pub user: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ChatMessage {
-    pub role: String,
-    pub content: String,
-    pub name: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ChatCompletionResponse {
-    pub id: String,
-    pub object: String,
-    pub created: i64,
-    pub model: String,
-    pub choices: Vec<ChatChoice>,
-    pub usage: Option<Usage>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ChatChoice {
-    pub index: u32,
-    pub message: ChatMessage,
-    pub finish_reason: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Usage {
-    pub prompt_tokens: u32,
-    pub completion_tokens: u32,
-    pub total_tokens: u32,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ChatCompletionChunk {
-    pub id: String,
-    pub object: String,
-    pub created: i64,
-    pub model: String,
-    pub choices: Vec<ChatChunkChoice>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ChatChunkChoice {
-    pub index: u32,
-    pub delta: ChatDelta,
-    pub finish_reason: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ChatDelta {
-    pub content: Option<String>,
-    pub role: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AnthropicMessageRequest {
-    pub model: String,
-    pub messages: Vec<AnthropicMessage>,
-    pub max_tokens: u32,
-    pub temperature: Option<f32>,
-    pub top_p: Option<f32>,
-    pub top_k: Option<u32>,
-    pub stream: Option<bool>,
-    pub stop_sequences: Option<Vec<String>>,
-    pub system: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AnthropicMessage {
-    pub role: String,
-    pub content: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AnthropicMessageResponse {
-    pub id: String,
-    pub model: String,
-    pub role: String,
-    pub content: Vec<AnthropicContent>,
-    pub stop_reason: Option<String>,
-    pub stop_sequence: Option<String>,
-    pub usage: AnthropicUsage,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AnthropicContent {
-    #[serde(rename = "type")]
-    pub content_type: String,
-    pub text: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AnthropicUsage {
-    pub input_tokens: u32,
-    pub output_tokens: u32,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct LocalModel {
-    pub id: String,
-    pub name: String,
-    pub provider: String,
-    pub path: Option<String>,
-    pub context_length: u32,
-    pub supports_chat: bool,
-    pub supports_completion: bool,
-}
-
-pub type ChatCompletionStream = Pin<Box<dyn Stream<Item = Result<ChatCompletionChunk>> + Send>>;
-pub type AnthropicMessageStream = Pin<Box<dyn Stream<Item = Result<Value>> + Send>>;
-
-#[async_trait]
-pub trait InferenceBackend: Send + Sync {
-    async fn chat_completions(
-        &self,
-        request: ChatCompletionRequest,
-    ) -> Result<ChatCompletionResponse>;
-
-    async fn chat_completions_stream(
-        &self,
-        request: ChatCompletionRequest,
-    ) -> Result<ChatCompletionStream>;
-
-    async fn messages(&self, request: AnthropicMessageRequest) -> Result<AnthropicMessageResponse>;
-
-    async fn messages_stream(
-        &self,
-        request: AnthropicMessageRequest,
-    ) -> Result<AnthropicMessageStream>;
-
-    async fn list_models(&self) -> Result<Vec<LocalModel>>;
-
-    async fn get_model(&self, model_id: &str) -> Result<Option<LocalModel>>;
-
-    async fn health_check(&self) -> Result<bool> {
-        Ok(true)
-    }
-}
diff --git a/crates/core/src/lib.rs b/crates/core/src/lib.rs
deleted file mode 100644
index bae58604..00000000
--- a/crates/core/src/lib.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-pub mod access;
-pub mod context;
-pub mod errors;
-pub mod inference;
-pub mod router;
-pub mod state;
-pub mod types;
-
-#[cfg(feature = "tracing")]
-#[macro_use]
-extern crate tracing as tracing_crate;
-
-#[cfg(feature = "tracing")]
-#[macro_use]
-pub mod tracing;
-
-#[cfg(any(test, feature = "tests"))]
-pub mod tests;
-
-pub use context::RequestContext;
-pub use errors::{Error, Result};
-pub use inference::InferenceBackend;
-pub use state::StateBackend;
-
-// Re-export types for convenience
-pub use types::{
-    ApiKey, Error as ProtoError, HookAction, HookResponse, Model, ModelType, Organization,
-    Provider, ProviderType, RequestHookContext, ResponseHookContext, TimeRange, UsageRecord, User,
-};
diff --git a/crates/core/src/router/executor.rs b/crates/core/src/router/executor.rs
deleted file mode 100644
index 4b58116d..00000000
--- a/crates/core/src/router/executor.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-use super::plan::{Route, RoutingPlan};
-use super::registry::SinkRegistry;
-use super::sink::{RequestContext, Sink};
-use super::types::{RequestStream, ResponseChunk, StopReason};
-use crate::Result;
-use std::sync::Arc;
-use std::time::Duration;
-
-pub struct PlanExecutor {
-    sink_registry: Arc<SinkRegistry>,
-}
-
-impl PlanExecutor {
-    pub fn new(sink_registry: Arc<SinkRegistry>) -> Self {
-        Self { sink_registry }
-    }
-
-    pub async fn execute(
-        &self,
-        plan: RoutingPlan,
-        request: RequestStream,
-    ) -> Result<super::sink::ResponseStream> {
-        let result = self
-            .execute_route(&plan.context, request, &plan.primary_route)
-            .await;
-        match result {
-            Ok(stream) => Ok(stream),
-            Err(primary_err) => {
-                #[cfg(feature = "tracing")]
-                {
-                    warn!(
-                        "Primary route failed: {} - {}",
-                        plan.primary_route.sink_id, primary_err
-                    );
-                }
-                Err(primary_err)
-            }
-        }
-    }
-
-    async fn execute_route(
-        &self,
-        ctx: &RequestContext,
-        request: RequestStream,
-        route: &Route,
-    ) -> Result<super::sink::ResponseStream> {
-        let sink = self
-            .sink_registry
-            .get(&route.sink_id)
-            .await
-            .ok_or_else(|| crate::Error::Internal(format!("Sink not found: {}", route.sink_id)))?;
-
-        if route.protocol_conversion.is_some() {
-            return Err(crate::Error::UnsupportedConversion(
-                "from".into(),
-                "to".into(),
-            ));
-        }
-
-        self.execute_with_retries(ctx, sink, request, &route.retry_config, route.timeout)
-            .await
-    }
-
-    async fn execute_with_retries(
-        &self,
-        ctx: &RequestContext,
-        sink: Arc<dyn Sink>,
-        request: RequestStream,
-        _retry_config: &super::types::RetryConfig,
-        timeout: Duration,
-    ) -> Result<super::sink::ResponseStream> {
-        match tokio::time::timeout(timeout, sink.execute(ctx, request)).await {
-            Ok(Ok(stream)) => Ok(stream),
-            Ok(Err(err)) => Err(err),
-            Err(_) => {
-                let chunk = ResponseChunk::Stop {
-                    reason: StopReason::Timeout,
-                    error: Some("Request timed out".to_string()),
-                    cost: None,
-                };
-                let stream = futures::stream::once(async move { Ok(chunk) });
-                Ok(Box::pin(stream))
-            }
-        }
-    }
-}
diff --git a/crates/core/src/router/index.rs b/crates/core/src/router/index.rs
deleted file mode 100644
index a1ec49e3..00000000
--- a/crates/core/src/router/index.rs
+++ /dev/null
@@ -1,91 +0,0 @@
-//! SinkIndex: caller-managed snapshots of sink descriptions and health
-
-use tokio::sync::RwLock;
-
-use super::registry::SinkRegistry;
-use super::sink::SinkDescription;
-use super::types::SinkHealth;
-use std::collections::HashMap;
-use std::sync::Arc;
-
-/// Snapshot of a sink's description and health
-#[derive(Clone, Debug)]
-pub struct SinkSnapshot {
-    pub description: SinkDescription,
-    pub health: SinkHealth,
-    pub updated_at: chrono::DateTime<chrono::Utc>,
-}
-
-/// Caller-managed index of sink snapshots for fast routing
-#[derive(Default, Debug, Clone)]
-pub struct SinkIndex {
-    inner: Arc<RwLock<HashMap<String, SinkSnapshot>>>,
-}
-
-impl SinkIndex {
-    pub fn new() -> Self {
-        Self {
-            inner: Arc::new(RwLock::new(HashMap::new())),
-        }
-    }
-
-    /// Set or update a snapshot for a sink ID (URL)
-    pub async fn set_snapshot(
-        &self,
-        sink_id: String,
-        description: SinkDescription,
-        health: SinkHealth,
-    ) {
-        let mut guard = self.inner.write().await;
-        guard.insert(
-            sink_id,
-            SinkSnapshot {
-                description,
-                health,
-                updated_at: chrono::Utc::now(),
-            },
-        );
-    }
-
-    /// Remove a snapshot
-    pub async fn remove(&self, sink_id: &str) {
-        let mut guard = self.inner.write().await;
-        guard.remove(sink_id);
-    }
-
-    /// Get a snapshot by sink ID
-    pub async fn get(&self, sink_id: &str) -> Option<SinkSnapshot> {
-        let guard = self.inner.read().await;
-        guard.get(sink_id).cloned()
-    }
-
-    /// List all snapshots
-    pub async fn list(&self) -> Vec<(String, SinkSnapshot)> {
-        let guard = self.inner.read().await;
-        guard.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
-    }
-
-    /// Refresh snapshots from the given registry (all sinks)
-    pub async fn refresh_from_registry(&self, registry: &SinkRegistry) -> usize {
-        let ids = registry.list_ids().await;
-        self.refresh_subset_from_registry(registry, &ids).await
-    }
-
-    /// Refresh a subset of sink IDs from the registry
-    pub async fn refresh_subset_from_registry(
-        &self,
-        registry: &SinkRegistry,
-        ids: &[String],
-    ) -> usize {
-        let mut count = 0usize;
-        for id in ids {
-            if let Some(sink) = registry.get(id).await {
-                let desc = sink.describe().await;
-                let health = sink.probe().await;
-                self.set_snapshot(id.clone(), desc, health).await;
-                count += 1;
-            }
-        }
-        count
-    }
-}
diff --git a/crates/core/src/router/middleware/cost_tracker.rs b/crates/core/src/router/middleware/cost_tracker.rs
deleted file mode 100644
index 00e93bd1..00000000
--- a/crates/core/src/router/middleware/cost_tracker.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-//! Cost tracking middleware
-
-use super::{Middleware, Next, RequestStream, ResponseStream};
-use crate::router::sink::RequestContext;
-use crate::router::types::{ActualCost, ResponseChunk};
-use crate::state::StateBackend;
-use crate::{Result, UsageRecord};
-use async_trait::async_trait;
-use futures::StreamExt;
-use std::sync::Arc;
-
-/// Cost tracking middleware
-pub struct CostTrackerMiddleware<S: StateBackend + 'static> {
-    state_backend: Arc<S>,
-}
-
-impl<S: StateBackend + 'static> CostTrackerMiddleware<S> {
-    /// Create a new cost tracker middleware
-    pub fn new(state_backend: Arc<S>) -> Self {
-        Self { state_backend }
-    }
-}
-
-#[async_trait]
-impl<S: StateBackend + 'static> Middleware for CostTrackerMiddleware<S> {
-    async fn process(
-        &self,
-        ctx: &mut RequestContext,
-        request: RequestStream,
-        next: Next,
-    ) -> Result<ResponseStream> {
-        // Forward the request
-        let mut response_stream = next(request).await?;
-
-        // Create a new stream that intercepts cost information
-        let state_backend = self.state_backend.clone();
-        let ctx_clone = ctx.clone();
-
-        let intercepted_stream = async_stream::stream! {
-            let mut total_cost: Option<ActualCost> = None;
-            let mut model = String::new();
-            let mut provider = String::new();
-
-            while let Some(chunk_result) = response_stream.next().await {
-                match chunk_result {
-                    Ok(chunk) => {
-                        // Intercept metadata for model/provider
-                        // Extract metadata
-                        if let ResponseChunk::Metadata(ref metadata) = chunk {
-                            if let Some(m) = metadata.get("model").and_then(|v| v.as_str()) {
-                                model = m.to_string();
-                            }
-                            if let Some(p) = metadata.get("provider").and_then(|v| v.as_str()) {
-                                provider = p.to_string();
-                            }
-                        }
-
-                        // Intercept final cost on Stop
-                        if let ResponseChunk::Stop { cost: Some(ref c), .. } = chunk {
-                            total_cost = Some(c.clone());
-                        }
-
-                        yield Ok(chunk);
-                    }
-                    Err(e) => {
-                        yield Err(e);
-                    }
-                }
-            }
-
-            // Record usage if we have cost information
-            if let Some(cost) = total_cost {
-                let usage = UsageRecord {
-                    id: uuid::Uuid::new_v4().to_string(),
-                    org_id: ctx_clone.identity.context.org_id.clone().unwrap_or_default(),
-                    user_id: ctx_clone.identity.context.user_id.clone().unwrap_or_default(),
-                    api_key_hash: ctx_clone.identity.context.api_key_hash.clone().unwrap_or_default(),
-                    request_id: ctx_clone.trace_id.clone().unwrap_or_default(),
-                    provider_id: provider,
-                    model_id: model,
-                    input_tokens: cost.input_tokens as u64,
-                    output_tokens: cost.output_tokens as u64,
-                    total_tokens: (cost.input_tokens + cost.output_tokens) as u64,
-                    cost: cost.total_cost_usd.to_string().parse().unwrap_or(0.0),
-                    timestamp: chrono::Utc::now(),
-                    metadata: std::collections::HashMap::new(),
-                };
-
-                if let Err(e) = state_backend.record_usage(&usage).await {
-                    #[cfg(feature = "tracing")]
-                    {
-                        error!("Failed to record usage: {}", e);
-                    }
-                    let _ = e; // Suppress unused warning when tracing is disabled
-                }
-            }
-        };
-
-        Ok(Box::pin(intercepted_stream))
-    }
-}
diff --git a/crates/core/src/router/middleware/key_capture.rs b/crates/core/src/router/middleware/key_capture.rs
deleted file mode 100644
index e73acff9..00000000
--- a/crates/core/src/router/middleware/key_capture.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-use super::{Middleware, Next, RequestStream, ResponseStream};
-use crate::Result;
-use crate::router::sink::RequestContext;
-use crate::router::types::{Protocol, ResponseChunk, StopReason};
-use async_trait::async_trait;
-use futures::StreamExt;
-use http::header::AUTHORIZATION;
-use std::sync::Arc;
-
-/// Hook for registering providers on successful responses
-#[async_trait]
-pub trait KeyCaptureRegistrar: Send + Sync {
-    async fn register_anthropic_key(&self, key: &str) -> Result<()>;
-}
-
-/// Middleware that captures Anthropic API keys on successful requests
-pub struct KeyCaptureMiddleware<R: KeyCaptureRegistrar + 'static> {
-    registrar: Arc<R>,
-}
-
-impl<R: KeyCaptureRegistrar + 'static> KeyCaptureMiddleware<R> {
-    pub fn new(registrar: Arc<R>) -> Self {
-        Self { registrar }
-    }
-
-    fn extract_anthropic_key(ctx: &RequestContext) -> Option<String> {
-        if let Some(val) = ctx.headers.get("x-api-key")
-            && let Ok(key) = val.to_str()
-            && key.starts_with("sk-ant-")
-        {
-            return Some(key.to_string());
-        }
-        if let Some(val) = ctx.headers.get(AUTHORIZATION)
-            && let Ok(auth) = val.to_str()
-            && let Some(token) = auth.strip_prefix("Bearer ")
-            && token.starts_with("sk-ant-")
-        {
-            return Some(token.to_string());
-        }
-        None
-    }
-}
-
-#[async_trait]
-impl<R: KeyCaptureRegistrar + 'static> Middleware for KeyCaptureMiddleware<R> {
-    async fn process(
-        &self,
-        ctx: &mut RequestContext,
-        request: RequestStream,
-        next: Next,
-    ) -> Result<ResponseStream> {
-        // Only attempt capture for Anthropic protocol
-        let protocol = request.protocol();
-        let maybe_key = if protocol == Protocol::Anthropic {
-            Self::extract_anthropic_key(ctx)
-        } else {
-            None
-        };
-
-        // Forward
-        let mut response_stream = next(request).await?;
-
-        if maybe_key.is_none() {
-            return Ok(response_stream);
-        }
-
-        let key = maybe_key.unwrap();
-        let registrar = self.registrar.clone();
-
-        let intercepted = async_stream::stream! {
-            let mut captured = false;
-            while let Some(item) = response_stream.next().await {
-                if let Ok(ResponseChunk::Stop { reason, error, .. }) = &item && !captured && matches!(reason, StopReason::Complete) && error.is_none() {
-                        // Best-effort capture, ignore errors
-                        let _ = registrar.register_anthropic_key(&key).await;
-                        captured = true;
-                }
-                yield item;
-            }
-        };
-
-        Ok(Box::pin(intercepted))
-    }
-}
diff --git a/crates/core/src/router/middleware/mod.rs b/crates/core/src/router/middleware/mod.rs
deleted file mode 100644
index 15344bc2..00000000
--- a/crates/core/src/router/middleware/mod.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-//! Middleware system for request/response processing
-
-mod cost_tracker;
-mod key_capture;
-mod monitor;
-mod rate_limit;
-
-pub use cost_tracker::CostTrackerMiddleware;
-pub use key_capture::{KeyCaptureMiddleware, KeyCaptureRegistrar};
-pub use monitor::MonitoringMiddleware;
-pub use rate_limit::RateLimitMiddleware;
-
-use crate::Result;
-use async_trait::async_trait;
-use futures::Stream;
-use futures::future::BoxFuture;
-use std::pin::Pin;
-
-/// Stream of request data
-pub type RequestStream = super::types::RequestStream;
-
-/// Stream of response data
-pub type ResponseStream = Pin<Box<dyn Stream<Item = Result<super::types::ResponseChunk>> + Send>>;
-
-/// Next middleware in the chain
-pub type Next = Box<dyn FnOnce(RequestStream) -> BoxFuture<'static, Result<ResponseStream>> + Send>;
-
-/// Middleware trait for processing requests and responses
-#[async_trait]
-pub trait Middleware: Send + Sync {
-    /// Process the request/response through this middleware
-    async fn process(
-        &self,
-        ctx: &mut super::sink::RequestContext,
-        request: RequestStream,
-        next: Next,
-    ) -> Result<ResponseStream>;
-}
diff --git a/crates/core/src/router/middleware/monitor.rs b/crates/core/src/router/middleware/monitor.rs
deleted file mode 100644
index 7f03862d..00000000
--- a/crates/core/src/router/middleware/monitor.rs
+++ /dev/null
@@ -1,166 +0,0 @@
-//! Monitoring middleware for observability
-
-use super::{Middleware, Next, RequestStream, ResponseStream};
-use crate::Result;
-use crate::router::sink::RequestContext;
-use crate::router::types::ResponseChunk;
-use async_trait::async_trait;
-use futures::StreamExt;
-use std::time::Instant;
-
-/// Monitoring middleware for metrics and tracing
-pub struct MonitoringMiddleware {
-    service_name: String,
-}
-
-impl MonitoringMiddleware {
-    /// Create a new monitoring middleware
-    pub fn new(service_name: String) -> Self {
-        Self { service_name }
-    }
-}
-
-impl Default for MonitoringMiddleware {
-    fn default() -> Self {
-        Self::new("gate-router".to_string())
-    }
-}
-
-#[async_trait]
-impl Middleware for MonitoringMiddleware {
-    async fn process(
-        &self,
-        ctx: &mut RequestContext,
-        request: RequestStream,
-        next: Next,
-    ) -> Result<ResponseStream> {
-        let start_time = Instant::now();
-        let trace_id = ctx
-            .trace_id
-            .clone()
-            .unwrap_or_else(|| "unknown".to_string());
-
-        // Log request start
-        #[cfg(feature = "tracing")]
-        {
-            info!(
-                service = %self.service_name,
-                trace_id = %trace_id,
-                user_id = ?ctx.identity.context.user_id,
-                "Processing request"
-            );
-        }
-
-        // Process the request
-        let result = next(request).await;
-
-        match &result {
-            Ok(_) => {
-                let duration = start_time.elapsed();
-                #[cfg(feature = "tracing")]
-                {
-                    info!(
-                        service = %self.service_name,
-                        trace_id = %trace_id,
-                        duration_ms = %duration.as_millis(),
-                        "Request completed successfully"
-                    );
-                }
-
-                // Wrap the stream to monitor chunks
-                let mut stream = result?;
-                let service_name = self.service_name.clone();
-                let trace_id_clone = trace_id.clone();
-
-                let monitored_stream = async_stream::stream! {
-                    let mut chunk_count = 0;
-                    let mut total_tokens = 0u32;
-                    let mut has_error = false;
-
-                    while let Some(chunk_result) = stream.next().await {
-                        match chunk_result {
-                            Ok(chunk) => {
-                                chunk_count += 1;
-
-                                // Track token usage
-                                if let ResponseChunk::Usage { prompt_tokens, completion_tokens } = &chunk {
-                                    total_tokens = prompt_tokens + completion_tokens;
-                                    #[cfg(feature = "tracing")]
-                                    {
-                                        debug!(
-                                            service = %service_name,
-                                            trace_id = %trace_id_clone,
-                                            prompt_tokens = %prompt_tokens,
-                                            completion_tokens = %completion_tokens,
-                                            "Token usage"
-                                        );
-                                    }
-                                }
-
-                                // Track errors
-                                if let ResponseChunk::Stop { error: Some(err), .. } = &chunk {
-                                    has_error = true;
-                                    #[cfg(feature = "tracing")]
-                                    {
-                                        error!(
-                                            service = %service_name,
-                                            trace_id = %trace_id_clone,
-                                            error = %err,
-                                            "Stream error"
-                                        );
-                                    }
-                                }
-
-                                yield Ok(chunk);
-                            }
-                            Err(e) => {
-                                has_error = true;
-                                #[cfg(feature = "tracing")]
-                                {
-                                    error!(
-                                        service = %service_name,
-                                        trace_id = %trace_id_clone,
-                                        error = %e,
-                                        "Stream processing error"
-                                    );
-                                }
-                                yield Err(e);
-                            }
-                        }
-                    }
-
-                    // Log stream completion
-                    let total_duration = start_time.elapsed();
-                    #[cfg(feature = "tracing")]
-                    {
-                        info!(
-                            service = %service_name,
-                            trace_id = %trace_id_clone,
-                            chunks = %chunk_count,
-                            total_tokens = %total_tokens,
-                            duration_ms = %total_duration.as_millis(),
-                            success = %!has_error,
-                            "Stream completed"
-                        );
-                    }
-                };
-
-                Ok(Box::pin(monitored_stream))
-            }
-            Err(e) => {
-                let duration = start_time.elapsed();
-                #[cfg(feature = "tracing")]
-                {
-                    error!(
-                        service = %self.service_name,
-                        trace_id = %trace_id,
-                        duration_ms = %duration.as_millis(),
-                        error = %e,
-                        "Request failed"
-                    );
-                }
-                result
-            }
-        }
-    }
-}
diff --git a/crates/core/src/router/middleware/rate_limit.rs b/crates/core/src/router/middleware/rate_limit.rs
deleted file mode 100644
index 01aa99e0..00000000
--- a/crates/core/src/router/middleware/rate_limit.rs
+++ /dev/null
@@ -1,177 +0,0 @@
-//! Rate limiting middleware
-
-use super::{Middleware, Next, RequestStream, ResponseStream};
-use crate::Result;
-use crate::router::sink::RequestContext;
-use crate::router::types::QuotaBehavior;
-use async_trait::async_trait;
-use std::collections::HashMap;
-use std::sync::Arc;
-use tokio::sync::RwLock;
-use tokio::time::{Duration, Instant};
-
-/// Trait for pluggable rate limit queue backends
-#[async_trait]
-pub trait RateLimitQueue: Send + Sync {
-    async fn enqueue(&self, key: &str, timeout: Duration) -> Result<()>;
-    async fn release(&self, key: &str);
-}
-
-/// Rate limit configuration
-#[derive(Debug, Clone)]
-pub struct RateLimitConfig {
-    pub requests_per_minute: u32,
-    pub tokens_per_minute: Option<u32>,
-    pub behavior: QuotaBehavior,
-}
-
-impl Default for RateLimitConfig {
-    fn default() -> Self {
-        Self {
-            requests_per_minute: 60,
-            tokens_per_minute: Some(100_000),
-            behavior: QuotaBehavior::Reject,
-        }
-    }
-}
-
-/// Rate limiter state for a single key
-#[derive(Debug)]
-struct RateLimitState {
-    request_count: u32,
-    token_count: u32,
-    window_start: Instant,
-}
-
-impl RateLimitState {
-    fn new() -> Self {
-        Self {
-            request_count: 0,
-            token_count: 0,
-            window_start: Instant::now(),
-        }
-    }
-
-    fn reset_if_needed(&mut self, window_duration: Duration) {
-        if self.window_start.elapsed() >= window_duration {
-            self.request_count = 0;
-            self.token_count = 0;
-            self.window_start = Instant::now();
-        }
-    }
-}
-
-/// Rate limiting middleware
-pub struct RateLimitMiddleware {
-    config: RateLimitConfig,
-    states: Arc<RwLock<HashMap<String, RateLimitState>>>,
-    queue: Option<Arc<dyn RateLimitQueue>>, // optional external queue implementation
-}
-
-impl RateLimitMiddleware {
-    /// Create a new rate limit middleware
-    pub fn new(config: RateLimitConfig) -> Self {
-        Self {
-            config,
-            states: Arc::new(RwLock::new(HashMap::new())),
-            queue: None,
-        }
-    }
-
-    /// Set a pluggable queue implementation
-    pub fn with_queue(mut self, queue: Arc<dyn RateLimitQueue>) -> Self {
-        self.queue = Some(queue);
-        self
-    }
-
-    /// Get the rate limit key from the context
-    fn get_rate_limit_key(ctx: &RequestContext) -> String {
-        // Use user ID if available, otherwise use org ID, otherwise use a default
-        ctx.identity
-            .context
-            .user_id
-            .clone()
-            .or_else(|| ctx.identity.context.org_id.clone())
-            .unwrap_or_else(|| "default".to_string())
-    }
-
-    /// Check if the request is within rate limits
-    async fn check_rate_limit(&self, key: &str) -> Result<bool> {
-        let mut states = self.states.write().await;
-        let state = states
-            .entry(key.to_string())
-            .or_insert_with(RateLimitState::new);
-
-        // Reset window if needed
-        state.reset_if_needed(Duration::from_secs(60));
-
-        // Check request limit
-        if state.request_count >= self.config.requests_per_minute {
-            return match self.config.behavior {
-                QuotaBehavior::Reject => Err(crate::Error::QuotaExceeded(format!(
-                    "Request rate limit exceeded: {} requests per minute",
-                    self.config.requests_per_minute
-                ))),
-                QuotaBehavior::WarnOnly => {
-                    #[cfg(feature = "tracing")]
-                    {
-                        warn!(
-                            "Request rate limit exceeded for {}: {} requests",
-                            key, state.request_count
-                        );
-                    }
-                    Ok(true)
-                }
-                QuotaBehavior::TrackOverage => {
-                    #[cfg(feature = "tracing")]
-                    {
-                        info!(
-                            "Tracking overage for {}: {} requests over limit",
-                            key,
-                            state.request_count - self.config.requests_per_minute
-                        );
-                    }
-                    Ok(true)
-                }
-            };
-        }
-
-        // Increment request count
-        state.request_count += 1;
-        Ok(true)
-    }
-}
-
-#[async_trait]
-impl Middleware for RateLimitMiddleware {
-    async fn process(
-        &self,
-        ctx: &mut RequestContext,
-        request: RequestStream,
-        next: Next,
-    ) -> Result<ResponseStream> {
-        let key = Self::get_rate_limit_key(ctx);
-
-        // Check rate limit
-        // If over limits and behavior is Queue, optionally enqueue
-        match self.check_rate_limit(&key).await {
-            Ok(_) => {}
-            Err(e) => {
-                if let QuotaBehavior::Reject = self.config.behavior {
-                    return Err(e);
-                }
-                if let QuotaBehavior::TrackOverage | QuotaBehavior::WarnOnly = self.config.behavior
-                {
-                    // pass through
-                }
-            }
-        }
-
-        // Process the request
-        let response = next(request).await?;
-
-        // TODO: Token usage tracking could be added by inspecting the response stream
-
-        Ok(response)
-    }
-}
diff --git a/crates/core/src/router/mod.rs b/crates/core/src/router/mod.rs
deleted file mode 100644
index 4413ccf5..00000000
--- a/crates/core/src/router/mod.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//! Smart routing module for LLM inference requests
-//!
-//! This module provides intelligent routing of inference requests across multiple
-//! providers, protocols, and deployment contexts (WASM, local daemon, Cloudflare Workers).
-
-pub mod executor;
-pub mod index;
-pub mod middleware;
-pub mod plan;
-pub mod prelude;
-pub mod protocols;
-pub mod record;
-pub mod registry;
-pub mod routing;
-pub mod service;
-pub mod signals;
-pub mod sink;
-pub mod sinks;
-pub mod strategy;
-pub mod types;
-
-#[cfg(test)]
-mod tests;
-
-// Re-export main types
-pub use index::{SinkIndex, SinkSnapshot};
-pub use plan::{Route, RoutingPlan};
-pub use registry::SinkRegistry;
-pub use routing::Router;
-pub use sink::RequestContext;
-pub use sink::{ResponseStream, Sink, SinkDescription};
-pub use types::{
-    ActualCost, ModelCapabilities, Protocol, ResponseChunk, SinkCapabilities, SinkHealth,
-    StopReason, VirtualModel,
-};
diff --git a/crates/core/src/router/plan.rs b/crates/core/src/router/plan.rs
deleted file mode 100644
index 23c90ca9..00000000
--- a/crates/core/src/router/plan.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-//! Routing plan definition
-use super::protocols::ProtocolConversion;
-use super::sink::RequestContext;
-use super::types::RetryConfig;
-use rust_decimal::Decimal;
-use serde::{Deserialize, Serialize};
-use std::time::Duration;
-
-/// Executable routing plan
-#[derive(Debug, Clone)]
-pub struct RoutingPlan {
-    pub id: uuid::Uuid,
-    pub created_at: chrono::DateTime<chrono::Utc>,
-    pub context: RequestContext,
-    pub primary_route: Route,
-    pub fallback_routes: Vec<Route>,
-    pub estimated_cost: Option<Decimal>,
-}
-
-/// A single route in the plan
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Route {
-    pub sink_id: String,
-    pub protocol_conversion: Option<ProtocolConversion>,
-    pub timeout: Duration,
-    pub retry_config: RetryConfig,
-}
-
-impl RoutingPlan {
-    /// Create a new routing plan
-    pub fn new(context: RequestContext, primary_route: Route, fallback_routes: Vec<Route>) -> Self {
-        Self {
-            id: uuid::Uuid::new_v4(),
-            created_at: chrono::Utc::now(),
-            context,
-            primary_route,
-            fallback_routes,
-            estimated_cost: None,
-        }
-    }
-
-    /// Set estimated cost
-    pub fn with_estimated_cost(mut self, cost: Decimal) -> Self {
-        self.estimated_cost = Some(cost);
-        self
-    }
-}
diff --git a/crates/core/src/router/prelude.rs b/crates/core/src/router/prelude.rs
deleted file mode 100644
index 880ffdd8..00000000
--- a/crates/core/src/router/prelude.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-pub use super::executor::PlanExecutor;
-pub use super::plan::{Route, RoutingPlan};
-pub use super::registry::SinkRegistry;
-pub use super::routing::Router;
-pub use super::service::route_and_execute_json_with_protocol;
-pub use super::sink::{
-    RequestContext, ResponseStream, RouterIdentityContext, Sink, SinkDescription,
-};
-pub use super::types::{
-    ModelList, Protocol, RequestDescriptor, RequestStream, ResponseChunk, SinkCapabilities,
-    SinkHealth, StopReason,
-};
diff --git a/crates/core/src/router/protocols/capabilities.rs b/crates/core/src/router/protocols/capabilities.rs
deleted file mode 100644
index d1cad273..00000000
--- a/crates/core/src/router/protocols/capabilities.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-//! Request capability extraction
-
-use super::Protocol;
-use crate::router::types::RequestCapabilities;
-use serde_json::Value as JsonValue;
-
-/// Extract required capabilities from request
-pub fn extract_capabilities(request: &JsonValue, protocol: Protocol) -> RequestCapabilities {
-    RequestCapabilities {
-        needs_tools: detect_tools(request, protocol),
-        needs_vision: detect_vision(request, protocol),
-        needs_streaming: request
-            .get("stream")
-            .and_then(|v| v.as_bool())
-            .unwrap_or(false),
-        max_tokens: request
-            .get("max_tokens")
-            .and_then(|v| v.as_u64())
-            .map(|v| v as u32),
-        modalities: detect_modalities(request, protocol),
-    }
-}
-
-/// Detect if request needs tool/function support
-fn detect_tools(request: &JsonValue, _protocol: Protocol) -> bool {
-    request.get("tools").is_some()
-        || request.get("functions").is_some()
-        || request.get("tool_choice").is_some()
-        || request.get("function_call").is_some()
-}
-
-/// Detect if request contains image content
-fn detect_vision(request: &JsonValue, protocol: Protocol) -> bool {
-    match protocol {
-        Protocol::OpenAIChat => detect_vision_openai(request),
-        Protocol::Anthropic => detect_vision_anthropic(request),
-        _ => false,
-    }
-}
-
-/// Detect vision in OpenAI format
-fn detect_vision_openai(request: &JsonValue) -> bool {
-    if let Some(messages) = request.get("messages").and_then(|m| m.as_array()) {
-        for message in messages {
-            if let Some(content) = message.get("content") {
-                // Check if content is an array (multi-modal)
-                if let Some(content_array) = content.as_array() {
-                    for item in content_array {
-                        if let Some(item_type) = item.get("type").and_then(|t| t.as_str())
-                            && (item_type == "image_url" || item_type == "image")
-                        {
-                            return true;
-                        }
-                    }
-                }
-            }
-        }
-    }
-    false
-}
-
-/// Detect vision in Anthropic format
-fn detect_vision_anthropic(request: &JsonValue) -> bool {
-    if let Some(messages) = request.get("messages").and_then(|m| m.as_array()) {
-        for message in messages {
-            if let Some(content) = message.get("content").and_then(|c| c.as_array()) {
-                for block in content {
-                    if let Some(block_type) = block.get("type").and_then(|t| t.as_str())
-                        && block_type == "image"
-                    {
-                        return true;
-                    }
-                }
-            }
-        }
-    }
-    false
-}
-
-/// Detect modalities in the request
-fn detect_modalities(request: &JsonValue, protocol: Protocol) -> Vec<String> {
-    let mut modalities = vec!["text".to_string()];
-
-    if detect_vision(request, protocol) {
-        modalities.push("vision".to_string());
-    }
-
-    // Check for audio (future support)
-    if request.get("audio").is_some() {
-        modalities.push("audio".to_string());
-    }
-
-    modalities
-}
diff --git a/crates/core/src/router/protocols/convert.rs b/crates/core/src/router/protocols/convert.rs
deleted file mode 100644
index 7df2881a..00000000
--- a/crates/core/src/router/protocols/convert.rs
+++ /dev/null
@@ -1,465 +0,0 @@
-//! Protocol conversion implementations
-
-use super::Protocol;
-use crate::Result;
-use serde_json::{Value as JsonValue, json};
-
-/// Check if conversion between protocols is possible
-pub fn can_convert(from: Protocol, to: Protocol) -> bool {
-    match (from, to) {
-        (Protocol::Anthropic, Protocol::OpenAIChat) => true,
-        (Protocol::OpenAIChat, Protocol::Anthropic) => true,
-        (Protocol::OpenAICompletions, Protocol::OpenAIChat) => true,
-        (a, b) if a == b => true,
-        _ => false,
-    }
-}
-
-/// Get expected information loss for a conversion
-pub fn conversion_loss(from: Protocol, to: Protocol) -> Vec<String> {
-    match (from, to) {
-        (Protocol::Anthropic, Protocol::OpenAIChat) => vec![
-            "system prompts handled differently".to_string(),
-            "cache_control not supported".to_string(),
-        ],
-        (Protocol::OpenAIChat, Protocol::Anthropic) => vec![
-            "function_call becomes tool_use".to_string(),
-            "logprobs not supported".to_string(),
-        ],
-        (Protocol::OpenAICompletions, Protocol::OpenAIChat) => {
-            vec!["completion context becomes single user message".to_string()]
-        }
-        _ => vec![],
-    }
-}
-
-/// Convert request between protocols
-pub fn convert_request(
-    from: Protocol,
-    to: Protocol,
-    json: &JsonValue,
-) -> Result<(JsonValue, Vec<String>)> {
-    match (from, to) {
-        (Protocol::Anthropic, Protocol::OpenAIChat) => anthropic_to_openai_chat(json),
-        (Protocol::OpenAIChat, Protocol::Anthropic) => openai_chat_to_anthropic(json),
-        (Protocol::OpenAICompletions, Protocol::OpenAIChat) => completions_to_chat(json),
-        (a, b) if a == b => Ok((json.clone(), vec![])),
-        _ => Err(crate::Error::UnsupportedConversion(
-            format!("{from:?}"),
-            format!("{to:?}"),
-        )),
-    }
-}
-
-/// Convert response between protocols
-pub fn convert_response(
-    from: Protocol,
-    to: Protocol,
-    json: &JsonValue,
-) -> Result<(JsonValue, Vec<String>)> {
-    match (from, to) {
-        (Protocol::OpenAIChat, Protocol::Anthropic) => openai_chat_response_to_anthropic(json),
-        (Protocol::Anthropic, Protocol::OpenAIChat) => anthropic_response_to_openai_chat(json),
-        (a, b) if a == b => Ok((json.clone(), vec![])),
-        _ => Err(crate::Error::UnsupportedConversion(
-            format!("{from:?}"),
-            format!("{to:?}"),
-        )),
-    }
-}
-
-/// Convert Anthropic request to OpenAI chat format
-fn anthropic_to_openai_chat(json: &JsonValue) -> Result<(JsonValue, Vec<String>)> {
-    let mut warnings = Vec::new();
-    let mut result = json!({});
-
-    // Copy model
-    if let Some(model) = json.get("model") {
-        result["model"] = model.clone();
-    }
-
-    // Convert messages
-    if let Some(messages) = json.get("messages") {
-        let mut converted_messages = Vec::new();
-
-        // Add system message if present
-        if let Some(system) = json.get("system") {
-            converted_messages.push(json!({
-                "role": "system",
-                "content": system
-            }));
-        }
-
-        // Convert each message
-        if let Some(msg_array) = messages.as_array() {
-            for msg in msg_array {
-                let role = msg.get("role").and_then(|r| r.as_str()).unwrap_or("user");
-                let content = msg.get("content");
-
-                // Handle content blocks (Anthropic can have multiple content blocks)
-                if let Some(content_array) = content.and_then(|c| c.as_array()) {
-                    let mut text_parts = Vec::new();
-                    for block in content_array {
-                        if let Some(block_type) = block.get("type").and_then(|t| t.as_str()) {
-                            match block_type {
-                                "text" => {
-                                    if let Some(text) = block.get("text").and_then(|t| t.as_str()) {
-                                        text_parts.push(text.to_string());
-                                    }
-                                }
-                                "image" => {
-                                    warnings.push("Image content not fully supported".to_string());
-                                }
-                                _ => {
-                                    warnings
-                                        .push(format!("Content type {block_type} not supported"));
-                                }
-                            }
-                        }
-                    }
-                    converted_messages.push(json!({
-                        "role": role,
-                        "content": text_parts.join("\n")
-                    }));
-                } else if let Some(content_str) = content.and_then(|c| c.as_str()) {
-                    converted_messages.push(json!({
-                        "role": role,
-                        "content": content_str
-                    }));
-                }
-            }
-        }
-
-        result["messages"] = json!(converted_messages);
-    }
-
-    // Copy common parameters
-    for field in &["temperature", "max_tokens", "top_p", "stream", "stop"] {
-        if let Some(value) = json.get(*field) {
-            result[*field] = value.clone();
-        }
-    }
-
-    // Handle tools
-    if let Some(tools) = json.get("tools") {
-        result["tools"] = tools.clone();
-        if let Some(tool_choice) = json.get("tool_choice") {
-            result["tool_choice"] = tool_choice.clone();
-        }
-    }
-
-    // Warn about unsupported fields
-    if json.get("cache_control").is_some() {
-        warnings.push("cache_control not supported in OpenAI format".to_string());
-    }
-
-    Ok((result, warnings))
-}
-
-/// Convert OpenAI chat to Anthropic format
-fn openai_chat_to_anthropic(json: &JsonValue) -> Result<(JsonValue, Vec<String>)> {
-    let mut warnings = Vec::new();
-    let mut result = json!({
-        "anthropic_version": "2024-10-22"
-    });
-
-    // Copy model
-    if let Some(model) = json.get("model") {
-        result["model"] = model.clone();
-    }
-
-    // Convert messages
-    if let Some(messages) = json.get("messages").and_then(|m| m.as_array()) {
-        let mut system_content = None;
-        let mut converted_messages = Vec::new();
-
-        for msg in messages {
-            let role = msg.get("role").and_then(|r| r.as_str()).unwrap_or("user");
-            let content = msg.get("content");
-
-            match role {
-                "system" => {
-                    // Anthropic uses a separate system field
-                    if let Some(content_str) = content.and_then(|c| c.as_str()) {
-                        system_content = Some(content_str.to_string());
-                    }
-                }
-                "assistant" => {
-                    if let Some(content_str) = content.and_then(|c| c.as_str()) {
-                        converted_messages.push(json!({
-                            "role": "assistant",
-                            "content": [{
-                                "type": "text",
-                                "text": content_str
-                            }]
-                        }));
-                    }
-                }
-                "user" => {
-                    if let Some(content_str) = content.and_then(|c| c.as_str()) {
-                        converted_messages.push(json!({
-                            "role": "user",
-                            "content": [{
-                                "type": "text",
-                                "text": content_str
-                            }]
-                        }));
-                    }
-                }
-                _ => {
-                    warnings.push(format!("Unknown role: {role}"));
-                }
-            }
-        }
-
-        if let Some(system) = system_content {
-            result["system"] = json!(system);
-        }
-        result["messages"] = json!(converted_messages);
-    }
-
-    // Copy common parameters
-    for field in &[
-        "temperature",
-        "max_tokens",
-        "top_p",
-        "stream",
-        "stop_sequences",
-    ] {
-        if let Some(value) = json.get(*field) {
-            result[*field] = value.clone();
-        }
-    }
-
-    // Handle tools/functions
-    if let Some(tools) = json.get("tools") {
-        result["tools"] = tools.clone();
-        if let Some(tool_choice) = json.get("tool_choice") {
-            result["tool_choice"] = tool_choice.clone();
-        }
-    } else if let Some(functions) = json.get("functions") {
-        // Convert functions to tools format
-        warnings.push("functions converted to tools format".to_string());
-        let mut tools = Vec::new();
-        if let Some(func_array) = functions.as_array() {
-            for func in func_array {
-                tools.push(json!({
-                    "type": "function",
-                    "function": func
-                }));
-            }
-        }
-        result["tools"] = json!(tools);
-    }
-
-    // Warn about unsupported fields
-    if json.get("logprobs").is_some() {
-        warnings.push("logprobs not supported in Anthropic format".to_string());
-    }
-    if json.get("n").is_some() && json.get("n") != Some(&json!(1)) {
-        warnings.push("n>1 not supported in Anthropic format".to_string());
-    }
-
-    Ok((result, warnings))
-}
-
-/// Convert OpenAI completions to chat format
-fn completions_to_chat(json: &JsonValue) -> Result<(JsonValue, Vec<String>)> {
-    let mut warnings = Vec::new();
-    let mut result = json!({});
-
-    // Copy model
-    if let Some(model) = json.get("model") {
-        result["model"] = model.clone();
-    }
-
-    // Convert prompt to messages
-    if let Some(prompt) = json.get("prompt") {
-        let content = if let Some(prompt_str) = prompt.as_str() {
-            prompt_str.to_string()
-        } else if let Some(prompt_array) = prompt.as_array() {
-            prompt_array
-                .iter()
-                .filter_map(|p| p.as_str())
-                .collect::<Vec<_>>()
-                .join("\n")
-        } else {
-            warnings.push("Complex prompt format not fully supported".to_string());
-            "".to_string()
-        };
-
-        result["messages"] = json!([{
-            "role": "user",
-            "content": content
-        }]);
-    }
-
-    // Copy common parameters
-    for field in &[
-        "temperature",
-        "max_tokens",
-        "top_p",
-        "stream",
-        "stop",
-        "presence_penalty",
-        "frequency_penalty",
-    ] {
-        if let Some(value) = json.get(*field) {
-            result[*field] = value.clone();
-        }
-    }
-
-    // Warn about completion-specific fields
-    if json.get("suffix").is_some() {
-        warnings.push("suffix not supported in chat format".to_string());
-    }
-    if json.get("echo").is_some() {
-        warnings.push("echo not supported in chat format".to_string());
-    }
-
-    Ok((result, warnings))
-}
-
-/// Convert OpenAI chat response to Anthropic format
-fn openai_chat_response_to_anthropic(json: &JsonValue) -> Result<(JsonValue, Vec<String>)> {
-    let mut warnings = Vec::new();
-    let mut result = json!({
-        "type": "message"
-    });
-
-    // Copy ID
-    if let Some(id) = json.get("id") {
-        result["id"] = id.clone();
-    }
-
-    // Copy model
-    if let Some(model) = json.get("model") {
-        result["model"] = model.clone();
-    }
-
-    // Convert choices to content
-    if let Some(choices) = json.get("choices").and_then(|c| c.as_array()) {
-        if let Some(first_choice) = choices.first() {
-            if let Some(message) = first_choice.get("message") {
-                let role = message
-                    .get("role")
-                    .and_then(|r| r.as_str())
-                    .unwrap_or("assistant");
-                result["role"] = json!(role);
-
-                if let Some(content) = message.get("content").and_then(|c| c.as_str()) {
-                    result["content"] = json!([{
-                        "type": "text",
-                        "text": content
-                    }]);
-                }
-
-                // Handle tool calls
-                if let Some(tool_calls) = message.get("tool_calls") {
-                    result["tool_calls"] = tool_calls.clone();
-                }
-            }
-
-            // Copy finish reason
-            if let Some(finish_reason) = first_choice.get("finish_reason") {
-                result["stop_reason"] = match finish_reason.as_str() {
-                    Some("stop") => json!("end_turn"),
-                    Some("length") => json!("max_tokens"),
-                    Some("tool_calls") => json!("tool_use"),
-                    _ => finish_reason.clone(),
-                };
-            }
-        }
-
-        if choices.len() > 1 {
-            warnings.push("Multiple choices not supported in Anthropic format".to_string());
-        }
-    }
-
-    // Convert usage
-    if let Some(usage) = json.get("usage") {
-        result["usage"] = json!({
-            "input_tokens": usage.get("prompt_tokens"),
-            "output_tokens": usage.get("completion_tokens")
-        });
-    }
-
-    Ok((result, warnings))
-}
-
-/// Convert Anthropic response to OpenAI chat format
-fn anthropic_response_to_openai_chat(json: &JsonValue) -> Result<(JsonValue, Vec<String>)> {
-    let warnings = Vec::new();
-    let mut result = json!({
-        "object": "chat.completion",
-        "created": chrono::Utc::now().timestamp()
-    });
-
-    // Copy ID
-    if let Some(id) = json.get("id") {
-        result["id"] = id.clone();
-    } else {
-        result["id"] = json!(format!("chatcmpl-{}", uuid::Uuid::new_v4()));
-    }
-
-    // Copy model
-    if let Some(model) = json.get("model") {
-        result["model"] = model.clone();
-    }
-
-    // Convert content to choices
-    let mut message = json!({
-        "role": json.get("role").unwrap_or(&json!("assistant"))
-    });
-
-    if let Some(content) = json.get("content").and_then(|c| c.as_array()) {
-        let mut text_parts = Vec::new();
-        for block in content {
-            if let Some(block_type) = block.get("type").and_then(|t| t.as_str())
-                && block_type == "text"
-                && let Some(text) = block.get("text").and_then(|t| t.as_str())
-            {
-                text_parts.push(text.to_string());
-            }
-        }
-        message["content"] = json!(text_parts.join("\n"));
-    } else if let Some(content_str) = json.get("content").and_then(|c| c.as_str()) {
-        message["content"] = json!(content_str);
-    }
-
-    // Handle tool use
-    if let Some(tool_calls) = json.get("tool_calls") {
-        message["tool_calls"] = tool_calls.clone();
-    }
-
-    // Convert stop reason to finish reason
-    let finish_reason = if let Some(stop_reason) = json.get("stop_reason").and_then(|s| s.as_str())
-    {
-        match stop_reason {
-            "end_turn" => "stop",
-            "max_tokens" => "length",
-            "tool_use" => "tool_calls",
-            _ => stop_reason,
-        }
-    } else {
-        "stop"
-    };
-
-    result["choices"] = json!([{
-        "index": 0,
-        "message": message,
-        "finish_reason": finish_reason
-    }]);
-
-    // Convert usage
-    if let Some(usage) = json.get("usage") {
-        result["usage"] = json!({
-            "prompt_tokens": usage.get("input_tokens"),
-            "completion_tokens": usage.get("output_tokens"),
-            "total_tokens": usage.get("input_tokens").and_then(|i| i.as_u64()).unwrap_or(0)
-                + usage.get("output_tokens").and_then(|o| o.as_u64()).unwrap_or(0)
-        });
-    }
-
-    Ok((result, warnings))
-}
diff --git a/crates/core/src/router/protocols/mod.rs b/crates/core/src/router/protocols/mod.rs
deleted file mode 100644
index 78df9372..00000000
--- a/crates/core/src/router/protocols/mod.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//! Protocol conversion and capabilities
-
-mod capabilities;
-mod convert;
-
-pub use crate::router::types::RequestCapabilities;
-pub use capabilities::extract_capabilities;
-pub use convert::{can_convert, conversion_loss, convert_request, convert_response};
-
-use super::types::Protocol;
-use serde::{Deserialize, Serialize};
-use serde_json::Value as JsonValue;
-
-/// Protocol conversion information
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ProtocolConversion {
-    pub from: Protocol,
-    pub to: Protocol,
-    pub expected_loss: Vec<String>,
-}
-
-/// Extract model from request
-pub fn extract_model(request: &JsonValue) -> Option<String> {
-    request
-        .get("model")
-        .and_then(|v| v.as_str())
-        .map(|s| s.to_string())
-}
diff --git a/crates/core/src/router/record.rs b/crates/core/src/router/record.rs
deleted file mode 100644
index 4c4aef5a..00000000
--- a/crates/core/src/router/record.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-//! Recording interfaces for request/response replay
-
-use crate::Result;
-use crate::router::sink::RequestContext;
-use crate::router::types::ResponseChunk;
-use async_trait::async_trait;
-use std::collections::HashMap;
-
-/// A recorded event in a request/response trace
-#[derive(Debug, Clone)]
-pub enum RecordEvent {
-    RequestHeaders(HashMap<String, String>),
-    RequestChunk(serde_json::Value),
-    RouteSelected { sink_url: String, rationale: String },
-    ResponseHeaders(HashMap<String, String>),
-    ResponseChunk(ResponseChunk),
-    Error(String),
-}
-
-/// Recorder trait for capturing request/response traces
-#[async_trait]
-pub trait Recorder: Send + Sync {
-    async fn begin(&self, ctx: &RequestContext) -> Result<String>; // returns a trace id
-    async fn record(&self, trace_id: &str, event: RecordEvent) -> Result<()>;
-    async fn end(&self, trace_id: &str) -> Result<()>;
-}
-
-/// A no-op recorder implementation
-pub struct NoopRecorder;
-
-#[async_trait]
-impl Recorder for NoopRecorder {
-    async fn begin(&self, _ctx: &RequestContext) -> Result<String> {
-        Ok(uuid::Uuid::new_v4().to_string())
-    }
-    async fn record(&self, _trace_id: &str, _event: RecordEvent) -> Result<()> {
-        Ok(())
-    }
-    async fn end(&self, _trace_id: &str) -> Result<()> {
-        Ok(())
-    }
-}
diff --git a/crates/core/src/router/registry.rs b/crates/core/src/router/registry.rs
deleted file mode 100644
index a7d6a768..00000000
--- a/crates/core/src/router/registry.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-use super::sink::Sink;
-use std::collections::HashMap;
-use std::sync::Arc;
-
-/// Registry for managing sinks
-pub struct SinkRegistry {
-    sinks: Arc<tokio::sync::RwLock<HashMap<String, Arc<dyn Sink>>>>,
-}
-
-impl SinkRegistry {
-    pub fn new() -> Self {
-        Self {
-            sinks: Arc::new(tokio::sync::RwLock::new(HashMap::new())),
-        }
-    }
-    pub async fn register(&self, id: String, sink: Arc<dyn Sink>) {
-        let mut sinks = self.sinks.write().await;
-        sinks.insert(id, sink);
-    }
-    pub async fn get(&self, id: &str) -> Option<Arc<dyn Sink>> {
-        let sinks = self.sinks.read().await;
-        sinks.get(id).cloned()
-    }
-    pub async fn remove(&self, id: &str) {
-        let mut sinks = self.sinks.write().await;
-        sinks.remove(id);
-    }
-    pub async fn list_ids(&self) -> Vec<String> {
-        let sinks = self.sinks.read().await;
-        sinks.keys().cloned().collect()
-    }
-    pub async fn get_all(&self) -> Vec<Arc<dyn Sink>> {
-        let sinks = self.sinks.read().await;
-        sinks.values().cloned().collect()
-    }
-}
-
-impl Default for SinkRegistry {
-    fn default() -> Self {
-        Self::new()
-    }
-}
diff --git a/crates/core/src/router/routing.rs b/crates/core/src/router/routing.rs
deleted file mode 100644
index 2e0304a7..00000000
--- a/crates/core/src/router/routing.rs
+++ /dev/null
@@ -1,469 +0,0 @@
-//! Router implementation for intelligent request routing
-
-use super::executor::PlanExecutor;
-use super::index::SinkIndex;
-use super::middleware::Middleware;
-use super::plan::{Route, RoutingPlan};
-use super::registry::SinkRegistry;
-use super::sink::{RequestContext, ResponseStream, Sink, SinkDescription};
-use super::strategy::{RoutingStrategy, ScoredRoute, SimpleStrategy, SinkCandidate};
-use super::types::{Protocol, RequestCapabilities, RequestDescriptor, RequestStream, RetryConfig};
-use super::{SinkHealth, SinkSnapshot};
-use crate::Result;
-use crate::router::SinkCapabilities;
-use crate::router::types::ModelList;
-use crate::state::StateBackend;
-use async_trait::async_trait;
-use chrono::Utc;
-use futures::future::BoxFuture;
-use std::cmp::Ordering;
-use std::collections::HashSet;
-use std::sync::Arc;
-use std::time::Duration;
-
-/// Router - makes routing decisions
-pub struct Router {
-    state_backend: Arc<dyn StateBackend>,
-    sink_registry: Arc<SinkRegistry>,
-    strategy: Box<dyn RoutingStrategy>,
-    middleware: Vec<Arc<dyn Middleware>>,
-    sink_index: Option<Arc<SinkIndex>>, // Optional fast-path index
-}
-
-impl Router {
-    /// Create a new router builder
-    pub fn builder() -> RouterBuilder {
-        RouterBuilder::new()
-    }
-
-    /// Route a request to create a plan
-    pub async fn route(
-        &self,
-        ctx: &RequestContext,
-        desc: &RequestDescriptor,
-    ) -> Result<RoutingPlan> {
-        // Resolve aliases for model
-        let concrete_models = self.resolve_model(&desc.model).await?;
-
-        // Find eligible sinks (no protocol conversion in v2)
-        let candidates = self
-            .find_eligible_sinks(
-                &concrete_models,
-                desc.protocol,
-                &desc.capabilities,
-                desc.context_length_hint,
-                self.sink_index.as_deref(),
-            )
-            .await?;
-
-        if candidates.is_empty() {
-            return Err(crate::Error::NoSinksAvailable);
-        }
-
-        // Apply routing strategy
-        let scored_routes = self.strategy.evaluate(ctx, desc, candidates).await?;
-        if scored_routes.is_empty() {
-            return Err(crate::Error::NoSinksAvailable);
-        }
-
-        // Convert to routes
-        let (primary, fallbacks) = self.create_routes(scored_routes)?;
-
-        // Create plan
-        Ok(RoutingPlan::new(ctx.clone(), primary, fallbacks))
-    }
-
-    /// Execute a routing plan
-    pub async fn execute(
-        &self,
-        plan: RoutingPlan,
-        request: RequestStream,
-    ) -> Result<ResponseStream> {
-        debug!("Executing routing plan: {:?}", self.sink_index);
-
-        let executor = PlanExecutor::new(self.sink_registry.clone());
-
-        // Build middleware pipeline around the executor
-        let middlewares = self.middleware.clone();
-        let ctx_arc = Arc::new(plan.context.clone());
-
-        // Terminal handler
-        let terminal = move |req: RequestStream| {
-            let executor = executor;
-            let plan = plan;
-            Box::pin(async move { executor.execute(plan, req).await })
-                as BoxFuture<'static, Result<ResponseStream>>
-        };
-
-        // Build chain from back to front
-        let mut next: super::middleware::Next = Box::new(terminal);
-        for mw in middlewares.into_iter().rev() {
-            let prev_next = next;
-            let ctx_iter = ctx_arc.clone();
-            next = Box::new(move |req_stream| {
-                let mw = mw.clone();
-                Box::pin(async move {
-                    let mut ctx_clone = (*ctx_iter).clone();
-                    mw.process(&mut ctx_clone, req_stream, prev_next).await
-                })
-            });
-        }
-
-        // Kick off the chain
-        next(request).await
-    }
-    /// Refresh the attached sink index from the current registry. Returns number of refreshed sinks.
-    pub async fn refresh_index(&self) -> Result<usize> {
-        if let Some(index) = &self.sink_index {
-            let n = index.refresh_from_registry(&self.sink_registry).await;
-            Ok(n)
-        } else {
-            Ok(0)
-        }
-    }
-
-    /// Resolve model aliases to concrete models
-    async fn resolve_model(&self, model: &str) -> Result<Vec<String>> {
-        // First check if it's an alias
-        match self.state_backend.resolve_model_alias(model).await {
-            Ok(models) if !models.is_empty() => Ok(models),
-            _ => Ok(vec![model.to_string()]), // Use as-is if not an alias
-        }
-    }
-
-    /// Find eligible sinks for the given models and protocol
-    async fn find_eligible_sinks(
-        &self,
-        models: &[String],
-        protocol: Protocol,
-        req_caps: &RequestCapabilities,
-        context_hint: Option<usize>,
-        index: Option<&SinkIndex>,
-    ) -> Result<Vec<SinkCandidate>> {
-        let mut candidates = Vec::new();
-
-        if let Some(index) = index {
-            // Use snapshots for hot path
-            let snapshots = index.list().await;
-            for (
-                sink_id,
-                SinkSnapshot {
-                    description,
-                    health,
-                    ..
-                },
-            ) in snapshots
-            {
-                let Some(sink) = self.sink_registry.get(&sink_id).await else {
-                    continue;
-                };
-
-                // Check if sink is healthy
-                if !health.healthy {
-                    continue;
-                }
-
-                // Check if sink supports any of the models
-                let supports_model = models.iter().any(|model| description.supports_model(model));
-                if !supports_model {
-                    continue;
-                }
-
-                // Check protocol support (no conversion in v2)
-                if !description.accepts_protocol(protocol) {
-                    continue;
-                }
-
-                // Check capability support
-                if req_caps.needs_streaming && !description.capabilities.supports_streaming {
-                    continue;
-                }
-
-                if req_caps.needs_tools && !description.capabilities.supports_tools {
-                    continue;
-                }
-
-                // Modalities (must include all requested)
-                let sink_modalities: HashSet<_> = description
-                    .capabilities
-                    .modalities
-                    .iter()
-                    .cloned()
-                    .collect();
-
-                let req_modalities: HashSet<_> = req_caps.modalities.iter().cloned().collect();
-                if !req_modalities.is_subset(&sink_modalities) {
-                    continue;
-                }
-
-                // Context length best-effort check
-                if let (Some(max_ctx), Some(input_hint)) =
-                    (description.capabilities.max_context_length, context_hint)
-                {
-                    let want_out = req_caps.max_tokens.unwrap_or(0) as usize;
-                    if input_hint + want_out > max_ctx {
-                        continue;
-                    }
-                }
-
-                candidates.push(SinkCandidate {
-                    sink: sink.clone(),
-                    description,
-                    health,
-                    needs_conversion: None,
-                });
-            }
-        } else {
-            // Fallback: query sinks directly (slower)
-            let sinks = self.sink_registry.get_all().await;
-
-            for sink in sinks {
-                let description = sink.describe().await;
-                let health = sink.probe().await;
-
-                if !health.healthy {
-                    continue;
-                }
-
-                let supports_model = models.iter().any(|model| description.supports_model(model));
-                if !supports_model {
-                    continue;
-                }
-
-                if !description.accepts_protocol(protocol) {
-                    continue;
-                }
-
-                if req_caps.needs_streaming && !description.capabilities.supports_streaming {
-                    continue;
-                }
-                if req_caps.needs_tools && !description.capabilities.supports_tools {
-                    continue;
-                }
-                let sink_modalities: HashSet<_> = description
-                    .capabilities
-                    .modalities
-                    .iter()
-                    .cloned()
-                    .collect();
-                let req_modalities: HashSet<_> = req_caps.modalities.iter().cloned().collect();
-                if !req_modalities.is_subset(&sink_modalities) {
-                    continue;
-                }
-                if let (Some(max_ctx), Some(input_hint)) =
-                    (description.capabilities.max_context_length, context_hint)
-                {
-                    let want_out = req_caps.max_tokens.unwrap_or(0) as usize;
-                    if input_hint + want_out > max_ctx {
-                        continue;
-                    }
-                }
-
-                candidates.push(SinkCandidate {
-                    sink: sink.clone(),
-                    description,
-                    health,
-                    needs_conversion: None,
-                });
-            }
-        }
-
-        Ok(candidates)
-    }
-
-    /// Create routes from scored routes
-    fn create_routes(&self, mut scored: Vec<ScoredRoute>) -> Result<(Route, Vec<Route>)> {
-        if scored.is_empty() {
-            return Err(crate::Error::NoSinksAvailable);
-        }
-
-        // Sort by score (highest first)
-        scored.sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap_or(Ordering::Equal));
-
-        let primary = scored.remove(0);
-        let primary_route = Route {
-            sink_id: primary.sink_id,
-            protocol_conversion: primary.conversion_needed,
-            timeout: Duration::from_secs(300),
-            retry_config: RetryConfig::default(),
-        };
-
-        let fallback_routes = scored
-            .into_iter()
-            .take(2) // Limit fallbacks
-            .map(|s| Route {
-                sink_id: s.sink_id,
-                protocol_conversion: s.conversion_needed,
-                timeout: Duration::from_secs(30),
-                retry_config: RetryConfig::default(),
-            })
-            .collect();
-
-        Ok((primary_route, fallback_routes))
-    }
-}
-
-// Router also implements Sink for composability
-#[async_trait]
-impl Sink for Router {
-    async fn describe(&self) -> SinkDescription {
-        // Aggregate descriptions from all sinks
-        let sinks = self.sink_registry.get_all().await;
-        let mut all_protocols = Vec::new();
-        let mut all_models = Vec::new();
-        let mut supports_streaming = false;
-        let mut supports_tools = false;
-        let mut max_context = 0usize;
-
-        for sink in sinks {
-            let desc = sink.describe().await;
-            for proto in desc.accepted_protocols {
-                if !all_protocols.contains(&proto) {
-                    all_protocols.push(proto);
-                }
-            }
-            if let ModelList::Static(models) = desc.models {
-                for model in models {
-                    if !all_models.contains(&model) {
-                        all_models.push(model);
-                    }
-                }
-            }
-            supports_streaming |= desc.capabilities.supports_streaming;
-            supports_tools |= desc.capabilities.supports_tools;
-            if let Some(ctx_len) = desc.capabilities.max_context_length {
-                max_context = max_context.max(ctx_len);
-            }
-        }
-
-        SinkDescription {
-            id: "router".to_string(),
-            accepted_protocols: all_protocols,
-            models: if all_models.is_empty() {
-                ModelList::Dynamic
-            } else {
-                ModelList::Static(all_models)
-            },
-            capabilities: SinkCapabilities {
-                supports_streaming,
-                supports_batching: false,
-                supports_tools,
-                max_context_length: Some(max_context),
-                modalities: vec!["text".to_string()],
-            },
-            cost_structure: None,
-        }
-    }
-
-    async fn probe(&self) -> SinkHealth {
-        // Aggregate health from all sinks
-        let sinks = self.sink_registry.get_all().await;
-        let mut healthy_count = 0;
-        let mut total_count = 0;
-
-        for sink in sinks {
-            let health = sink.probe().await;
-            total_count += 1;
-            if health.healthy {
-                healthy_count += 1;
-            }
-        }
-
-        SinkHealth {
-            healthy: healthy_count > 0,
-            latency_ms: None,
-            error_rate: if total_count > 0 {
-                1.0 - (healthy_count as f32 / total_count as f32)
-            } else {
-                1.0
-            },
-            last_error: None,
-            last_check: Utc::now(),
-        }
-    }
-
-    async fn execute(
-        &self,
-        _ctx: &RequestContext,
-        _request: RequestStream,
-    ) -> Result<ResponseStream> {
-        // Router-as-sink execution path requires request peeking to build a descriptor.
-        // Not yet implemented in v2 core.
-        Err(crate::Error::Internal(
-            "Router used as a sink: not implemented".into(),
-        ))
-    }
-}
-
-/// Builder for Router
-pub struct RouterBuilder {
-    state_backend: Option<Arc<dyn StateBackend>>,
-    sink_registry: Option<Arc<SinkRegistry>>,
-    strategy: Option<Box<dyn RoutingStrategy>>,
-    middleware: Vec<Arc<dyn Middleware>>,
-    sink_index: Option<Arc<SinkIndex>>,
-}
-
-impl RouterBuilder {
-    /// Create a new router builder
-    pub fn new() -> Self {
-        Self {
-            state_backend: None,
-            sink_registry: None,
-            strategy: None,
-            middleware: Vec::new(),
-            sink_index: None,
-        }
-    }
-
-    /// Set the state backend
-    pub fn state_backend(mut self, backend: Arc<dyn StateBackend>) -> Self {
-        self.state_backend = Some(backend);
-        self
-    }
-
-    /// Set the sink registry
-    pub fn sink_registry(mut self, registry: Arc<SinkRegistry>) -> Self {
-        self.sink_registry = Some(registry);
-        self
-    }
-
-    /// Set the routing strategy
-    pub fn strategy(mut self, strategy: Box<dyn RoutingStrategy>) -> Self {
-        self.strategy = Some(strategy);
-        self
-    }
-
-    /// Add middleware
-    pub fn middleware(mut self, middleware: Arc<dyn Middleware>) -> Self {
-        self.middleware.push(middleware);
-        self
-    }
-
-    /// Set an optional sink index to use for fast routing
-    pub fn sink_index(mut self, index: Arc<SinkIndex>) -> Self {
-        self.sink_index = Some(index);
-        self
-    }
-
-    /// Build the router
-    pub fn build(self) -> Router {
-        Router {
-            state_backend: self.state_backend.expect("state_backend is required"),
-            sink_registry: self
-                .sink_registry
-                .unwrap_or_else(|| Arc::new(SinkRegistry::new())),
-            strategy: self
-                .strategy
-                .unwrap_or_else(|| Box::new(SimpleStrategy::new())),
-            middleware: self.middleware,
-            sink_index: self.sink_index,
-        }
-    }
-}
-
-impl Default for RouterBuilder {
-    fn default() -> Self {
-        Self::new()
-    }
-}
diff --git a/crates/core/src/router/service.rs b/crates/core/src/router/service.rs
deleted file mode 100644
index 35324daf..00000000
--- a/crates/core/src/router/service.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-//! Helper service for routing from JSON requests
-
-use crate::Result;
-use crate::router::middleware::ResponseStream as MwResponseStream;
-use crate::router::protocols;
-use crate::router::routing::Router;
-use crate::router::sink::RequestContext;
-use crate::router::types::Protocol;
-use crate::router::types::{RequestDescriptor, RequestStream};
-use serde_json::Value as JsonValue;
-
-/// Build a RequestDescriptor from a single JSON request body for a known protocol
-pub fn descriptor_from_json_with_protocol(
-    json: &JsonValue,
-    protocol: Protocol,
-) -> Result<RequestDescriptor> {
-    let model = protocols::extract_model(json).unwrap_or_else(|| "unknown".to_string());
-    let capabilities = protocols::extract_capabilities(json, protocol);
-
-    // Best-effort context length hint: rough token estimate by chars/4
-    let context_length_hint = Some(json.to_string().len() / 4);
-
-    Ok(RequestDescriptor {
-        model,
-        protocol,
-        capabilities,
-        context_length_hint,
-    })
-}
-
-/// Build a one-off RequestStream from a single JSON payload
-pub fn one_shot_stream(protocol: Protocol, json: JsonValue) -> RequestStream {
-    RequestStream::new(
-        protocol,
-        Box::pin(futures::stream::once(async move { Ok(json) })),
-    )
-}
-
-/// Route and execute for a single JSON request with a known protocol
-pub async fn route_and_execute_json_with_protocol(
-    router: &Router,
-    ctx: &RequestContext,
-    protocol: Protocol,
-    json: JsonValue,
-) -> Result<MwResponseStream> {
-    let desc = descriptor_from_json_with_protocol(&json, protocol)?;
-    let plan = router.route(ctx, &desc).await?;
-    let stream = one_shot_stream(protocol, json);
-    router.execute(plan, stream).await
-}
diff --git a/crates/core/src/router/signals.rs b/crates/core/src/router/signals.rs
deleted file mode 100644
index 0ddce80b..00000000
--- a/crates/core/src/router/signals.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-use http::header::{AUTHORIZATION, HeaderName};
-
-/// Return Anthropic API key from headers, if present (either `x-api-key` or `Authorization: Bearer sk-ant-*`).
-pub fn anthropic_key_from(headers: &http::HeaderMap) -> Option<&str> {
-    let x_api_key = HeaderName::from_static("x-api-key");
-    if let Some(val) = headers.get(&x_api_key).and_then(|v| v.to_str().ok())
-        && val.starts_with("sk-ant-")
-    {
-        return Some(val);
-    }
-    if let Some(auth) = headers.get(AUTHORIZATION).and_then(|v| v.to_str().ok())
-        && let Some(token) = auth.strip_prefix("Bearer ")
-        && token.starts_with("sk-ant-")
-    {
-        return Some(token);
-    }
-    None
-}
-
-/// Return OpenAI bearer token from headers, if present (`Authorization: Bearer <token>`).
-pub fn openai_bearer_from(headers: &http::HeaderMap) -> Option<&str> {
-    if let Some(auth) = headers.get(AUTHORIZATION).and_then(|v| v.to_str().ok())
-        && let Some(token) = auth.strip_prefix("Bearer ")
-        && !token.is_empty()
-    {
-        return Some(token);
-    }
-    None
-}
-
-/// Whether headers contain Anthropic-specific signals (version header or key).
-pub fn has_anthropic_signal(headers: &http::HeaderMap) -> bool {
-    let anth_version = HeaderName::from_static("anthropic-version");
-    headers.contains_key(&anth_version) || anthropic_key_from(headers).is_some()
-}
-
-/// Whether headers contain OpenAI-specific signals (beta header or Authorization Bearer).
-pub fn has_openai_signal(headers: &http::HeaderMap) -> bool {
-    let openai_beta = HeaderName::from_static("openai-beta");
-    headers.contains_key(&openai_beta) || openai_bearer_from(headers).is_some()
-}
diff --git a/crates/core/src/router/sink.rs b/crates/core/src/router/sink.rs
deleted file mode 100644
index 3b074c0c..00000000
--- a/crates/core/src/router/sink.rs
+++ /dev/null
@@ -1,106 +0,0 @@
-//! Sink trait and core implementations
-
-use super::types::{
-    CostStructure, ModelList, Protocol, ResponseChunk, SinkCapabilities, SinkHealth,
-};
-use crate::{
-    Result,
-    access::{IdentityContext, SubjectIdentity},
-    tracing::CorrelationId,
-};
-use async_trait::async_trait;
-use futures::Stream;
-use http::HeaderMap;
-use serde::{Deserialize, Serialize};
-use std::pin::Pin;
-
-/// Stream of response chunks
-pub type ResponseStream = Pin<Box<dyn Stream<Item = Result<ResponseChunk>> + Send>>;
-
-/// Request context for request execution
-#[derive(Debug, Clone)]
-pub struct RequestContext {
-    pub identity: SubjectIdentity<RouterIdentityContext>,
-    pub correlation_id: CorrelationId,
-    /// Request headers supplied by the caller (not credentials)
-    pub headers: HeaderMap,
-    /// Raw query string from the incoming HTTP request (without leading '?')
-    pub query: Option<String>,
-    pub trace_id: Option<String>,
-    pub metadata: std::collections::HashMap<String, String>,
-}
-
-/// Identity context specific to router
-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
-pub struct RouterIdentityContext {
-    pub org_id: Option<String>,
-    pub user_id: Option<String>,
-    pub api_key_hash: Option<String>,
-}
-
-impl IdentityContext for RouterIdentityContext {
-    fn to_attributes(&self) -> std::collections::HashMap<String, String> {
-        let mut attrs = std::collections::HashMap::new();
-        if let Some(ref org_id) = self.org_id {
-            attrs.insert("org_id".to_string(), org_id.clone());
-        }
-        if let Some(ref user_id) = self.user_id {
-            attrs.insert("user_id".to_string(), user_id.clone());
-        }
-        if let Some(ref api_key_hash) = self.api_key_hash {
-            attrs.insert("api_key_hash".to_string(), api_key_hash.clone());
-        }
-        attrs
-    }
-
-    fn get(&self, key: &str) -> Option<&str> {
-        match key {
-            "org_id" => self.org_id.as_deref(),
-            "user_id" => self.user_id.as_deref(),
-            "api_key_hash" => self.api_key_hash.as_deref(),
-            _ => None,
-        }
-    }
-}
-
-/// Sink trait - anything that can receive and process requests
-#[async_trait]
-pub trait Sink: Send + Sync {
-    /// Describe sink capabilities
-    async fn describe(&self) -> SinkDescription;
-
-    /// Check sink health
-    async fn probe(&self) -> SinkHealth;
-
-    /// Execute request
-    async fn execute(
-        &self,
-        ctx: &RequestContext,
-        request: super::types::RequestStream,
-    ) -> Result<ResponseStream>;
-}
-
-/// Description of a sink's capabilities
-#[derive(Debug, Clone)]
-pub struct SinkDescription {
-    pub id: String,
-    pub accepted_protocols: Vec<Protocol>,
-    pub models: ModelList,
-    pub capabilities: SinkCapabilities,
-    pub cost_structure: Option<CostStructure>,
-}
-
-impl SinkDescription {
-    /// Check if this sink supports the given model
-    pub fn supports_model(&self, model: &str) -> bool {
-        match &self.models {
-            ModelList::Static(models) => models.iter().any(|m| m == model),
-            ModelList::Dynamic | ModelList::Infinite => true,
-        }
-    }
-
-    /// Check if this sink accepts the given protocol
-    pub fn accepts_protocol(&self, protocol: Protocol) -> bool {
-        self.accepted_protocols.contains(&protocol)
-    }
-}
diff --git a/crates/core/src/router/sinks/mock.rs b/crates/core/src/router/sinks/mock.rs
deleted file mode 100644
index 38496faf..00000000
--- a/crates/core/src/router/sinks/mock.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-//! Mock sink implementations for testing
-
-use crate::Result;
-use crate::router::sink::{RequestContext, Sink, SinkDescription};
-use crate::router::types::RequestStream;
-use crate::router::types::{ModelList, Protocol, ResponseChunk, SinkCapabilities, SinkHealth};
-use async_trait::async_trait;
-use futures::StreamExt;
-use serde_json::json;
-use std::pin::Pin;
-
-pub struct MockSink {
-    pub id: String,
-    pub accepted_protocols: Vec<Protocol>,
-    pub models: ModelList,
-    pub capabilities: SinkCapabilities,
-    pub healthy: bool,
-}
-
-impl MockSink {
-    pub fn success(id: &str) -> Self {
-        Self {
-            id: id.to_string(),
-            accepted_protocols: vec![Protocol::OpenAIChat, Protocol::Anthropic],
-            models: ModelList::Dynamic,
-            capabilities: SinkCapabilities {
-                supports_streaming: true,
-                supports_batching: false,
-                supports_tools: true,
-                max_context_length: Some(128_000),
-                modalities: vec!["text".into()],
-            },
-            healthy: true,
-        }
-    }
-
-    pub fn unhealthy(id: &str) -> Self {
-        let mut s = Self::success(id);
-        s.healthy = false;
-        s
-    }
-}
-
-#[async_trait]
-impl Sink for MockSink {
-    async fn describe(&self) -> SinkDescription {
-        SinkDescription {
-            id: self.id.clone(),
-            accepted_protocols: self.accepted_protocols.clone(),
-            models: self.models.clone(),
-            capabilities: self.capabilities.clone(),
-            cost_structure: None,
-        }
-    }
-
-    async fn probe(&self) -> SinkHealth {
-        SinkHealth {
-            healthy: self.healthy,
-            latency_ms: Some(50),
-            error_rate: if self.healthy { 0.0 } else { 1.0 },
-            last_error: None,
-            last_check: chrono::Utc::now(),
-        }
-    }
-
-    async fn execute(
-        &self,
-        _ctx: &RequestContext,
-        mut request: RequestStream,
-    ) -> Result<Pin<Box<dyn futures::Stream<Item = Result<ResponseChunk>> + Send>>> {
-        // Consume the request and echo a simple response
-        let mut messages = Vec::new();
-        while let Some(item) = request.next().await {
-            let v = item?;
-            messages.push(v);
-        }
-
-        let stream = async_stream::stream! {
-            yield Ok(ResponseChunk::Headers(Default::default()));
-            yield Ok(ResponseChunk::Content(json!({"ok": true, "echo": messages })));
-            yield Ok(ResponseChunk::Stop { reason: crate::router::types::StopReason::Complete, error: None, cost: None });
-        };
-        Ok(Box::pin(stream))
-    }
-}
diff --git a/crates/core/src/router/sinks/mod.rs b/crates/core/src/router/sinks/mod.rs
deleted file mode 100644
index 68109d17..00000000
--- a/crates/core/src/router/sinks/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-//! Sink implementations
-
-pub mod mock;
diff --git a/crates/core/src/router/strategy/best_of_n.rs b/crates/core/src/router/strategy/best_of_n.rs
deleted file mode 100644
index 0a8d22dd..00000000
--- a/crates/core/src/router/strategy/best_of_n.rs
+++ /dev/null
@@ -1,115 +0,0 @@
-//! Best-of-N sampling strategy
-
-use super::{RoutingStrategy, ScoredRoute, SinkCandidate};
-use crate::Result;
-use crate::router::sink::RequestContext;
-use crate::router::types::RequestDescriptor;
-use async_trait::async_trait;
-
-/// Selection method for best-of-N
-#[derive(Debug, Clone)]
-pub enum SelectionMethod {
-    /// Return the first complete response
-    FirstComplete,
-    /// Return the most common response (majority vote)
-    MajorityVote,
-    /// Return the response with highest confidence
-    HighestConfidence,
-    /// Use a judge model to select the best
-    JudgeModel(String),
-}
-
-/// Best-of-N sampling strategy
-pub struct BestOfNStrategy {
-    n: usize,
-    selection: SelectionMethod,
-}
-
-impl BestOfNStrategy {
-    /// Create a new best-of-N strategy
-    pub fn new(n: usize, selection: SelectionMethod) -> Self {
-        Self {
-            n: n.max(1),
-            selection,
-        }
-    }
-
-    /// Create a first-complete strategy
-    pub fn first_complete(n: usize) -> Self {
-        Self::new(n, SelectionMethod::FirstComplete)
-    }
-
-    /// Create a majority vote strategy
-    pub fn majority_vote(n: usize) -> Self {
-        Self::new(n, SelectionMethod::MajorityVote)
-    }
-
-    /// Create a judge-based strategy
-    pub fn with_judge(n: usize, judge_model: String) -> Self {
-        Self::new(n, SelectionMethod::JudgeModel(judge_model))
-    }
-}
-
-#[async_trait]
-impl RoutingStrategy for BestOfNStrategy {
-    async fn evaluate(
-        &self,
-        _ctx: &RequestContext,
-        _request: &RequestDescriptor,
-        mut candidates: Vec<SinkCandidate>,
-    ) -> Result<Vec<ScoredRoute>> {
-        // For best-of-N, we want to select N candidates that will all be executed
-        // Score them equally high so they're all selected
-
-        // Filter to healthy candidates only
-        candidates.retain(|c| c.health.healthy);
-
-        if candidates.is_empty() {
-            return Ok(vec![]);
-        }
-
-        // Take up to N candidates
-        let n_candidates = candidates.len().min(self.n);
-        let selected = candidates.into_iter().take(n_candidates);
-
-        let mut scored = Vec::new();
-        for (i, candidate) in selected.enumerate() {
-            // Give all selected candidates the same high score
-            // They will all be executed in parallel
-            let score = 1.0;
-
-            let rationale = match &self.selection {
-                SelectionMethod::FirstComplete => {
-                    format!("Best-of-{}: candidate {} (first-complete)", self.n, i + 1)
-                }
-                SelectionMethod::MajorityVote => {
-                    format!("Best-of-{}: candidate {} (majority-vote)", self.n, i + 1)
-                }
-                SelectionMethod::HighestConfidence => {
-                    format!(
-                        "Best-of-{}: candidate {} (highest-confidence)",
-                        self.n,
-                        i + 1
-                    )
-                }
-                SelectionMethod::JudgeModel(model) => {
-                    format!("Best-of-{}: candidate {} (judge: {})", self.n, i + 1, model)
-                }
-            };
-
-            scored.push(ScoredRoute {
-                sink_id: candidate.description.id.clone(),
-                score,
-                estimated_cost: None,
-                estimated_latency: candidate
-                    .health
-                    .latency_ms
-                    .map(std::time::Duration::from_millis),
-                conversion_needed: candidate.needs_conversion.clone(),
-                rationale,
-            });
-        }
-
-        Ok(scored)
-    }
-}
diff --git a/crates/core/src/router/strategy/cost.rs b/crates/core/src/router/strategy/cost.rs
deleted file mode 100644
index fc3a329f..00000000
--- a/crates/core/src/router/strategy/cost.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-//! Cost-optimized routing strategy
-
-use super::{RoutingStrategy, ScoredRoute, SinkCandidate};
-use crate::Result;
-use crate::router::sink::RequestContext;
-use crate::router::types::RequestDescriptor;
-use async_trait::async_trait;
-use rust_decimal::Decimal;
-
-/// Cost-optimized routing strategy
-pub struct CostOptimizedStrategy {
-    budget: Option<Decimal>,
-    prefer_cached: bool,
-}
-
-impl CostOptimizedStrategy {
-    /// Create a new cost-optimized strategy
-    pub fn new() -> Self {
-        Self {
-            budget: None,
-            prefer_cached: true,
-        }
-    }
-
-    /// Create with a budget limit
-    pub fn with_budget(budget: Decimal) -> Self {
-        Self {
-            budget: Some(budget),
-            prefer_cached: true,
-        }
-    }
-
-    /// Estimate cost for a request
-    fn estimate_cost(
-        &self,
-        candidate: &SinkCandidate,
-        request: &RequestDescriptor,
-    ) -> Option<Decimal> {
-        let cost_structure = candidate.description.cost_structure.as_ref()?;
-        // Estimate tokens (rough): use context_length_hint and max_tokens if available
-        let estimated_input_tokens = request.context_length_hint.unwrap_or(0) as u32;
-        let max_tokens = request.capabilities.max_tokens.unwrap_or(512);
-        let estimated_output_tokens = (max_tokens / 2).max(1);
-
-        let input_cost =
-            cost_structure.input_cost_per_token * Decimal::from(estimated_input_tokens);
-        let output_cost =
-            cost_structure.output_cost_per_token * Decimal::from(estimated_output_tokens);
-
-        Some(input_cost + output_cost)
-    }
-}
-
-impl Default for CostOptimizedStrategy {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[async_trait]
-impl RoutingStrategy for CostOptimizedStrategy {
-    async fn evaluate(
-        &self,
-        _ctx: &RequestContext,
-        request: &RequestDescriptor,
-        candidates: Vec<SinkCandidate>,
-    ) -> Result<Vec<ScoredRoute>> {
-        let mut scored = Vec::new();
-
-        for candidate in candidates {
-            let estimated_cost = self.estimate_cost(&candidate, request);
-
-            // Skip if over budget
-            if let (Some(budget), Some(cost)) = (self.budget, estimated_cost)
-                && cost > budget
-            {
-                continue;
-            }
-
-            // Calculate score based on cost (lower cost = higher score)
-            let cost_score = if let Some(cost) = estimated_cost {
-                // Normalize cost to 0-1 range (assuming max cost of $1)
-                let max_cost = Decimal::from(1);
-                let normalized = (max_cost - cost.min(max_cost)) / max_cost;
-                normalized.to_string().parse::<f64>().unwrap_or(0.5)
-            } else {
-                0.5 // Neutral score if cost unknown
-            };
-
-            // Boost score if sink supports caching and we prefer cached
-            let cache_boost = if self.prefer_cached
-                && candidate
-                    .description
-                    .cost_structure
-                    .as_ref()
-                    .and_then(|cs| cs.cached_input_cost_per_token)
-                    .is_some()
-            {
-                0.1
-            } else {
-                0.0
-            };
-
-            // Penalize unhealthy sinks
-            let health_penalty = if !candidate.health.healthy {
-                0.5
-            } else {
-                candidate.health.error_rate as f64
-            };
-
-            let final_score = (cost_score + cache_boost) * (1.0 - health_penalty);
-
-            scored.push(ScoredRoute {
-                sink_id: candidate.description.id.clone(),
-                score: final_score,
-                estimated_cost,
-                estimated_latency: candidate
-                    .health
-                    .latency_ms
-                    .map(std::time::Duration::from_millis),
-                conversion_needed: candidate.needs_conversion.clone(),
-                rationale: format!(
-                    "Cost-optimized: estimated_cost={estimated_cost:?}, score={final_score:.3}"
-                ),
-            });
-        }
-
-        // Sort by score (highest first)
-        scored.sort_by(|a, b| {
-            b.score
-                .partial_cmp(&a.score)
-                .unwrap_or(std::cmp::Ordering::Equal)
-        });
-
-        Ok(scored)
-    }
-}
diff --git a/crates/core/src/router/strategy/latency.rs b/crates/core/src/router/strategy/latency.rs
deleted file mode 100644
index bed4070c..00000000
--- a/crates/core/src/router/strategy/latency.rs
+++ /dev/null
@@ -1,123 +0,0 @@
-//! Latency-optimized routing strategy
-
-use super::{RoutingStrategy, ScoredRoute, SinkCandidate};
-use crate::Result;
-use crate::router::sink::RequestContext;
-use crate::router::types::RequestDescriptor;
-use async_trait::async_trait;
-use std::time::Duration;
-
-/// Latency-optimized routing strategy
-pub struct LatencyOptimizedStrategy {
-    max_latency: Option<Duration>,
-    percentile: f64, // e.g., 0.95 for p95
-}
-
-impl LatencyOptimizedStrategy {
-    /// Create a new latency-optimized strategy
-    pub fn new() -> Self {
-        Self {
-            max_latency: None,
-            percentile: 0.95,
-        }
-    }
-
-    /// Create with a maximum latency threshold
-    pub fn with_max_latency(max_latency: Duration) -> Self {
-        Self {
-            max_latency: Some(max_latency),
-            percentile: 0.95,
-        }
-    }
-
-    /// Set the percentile to optimize for (e.g., 0.99 for p99)
-    pub fn with_percentile(mut self, percentile: f64) -> Self {
-        self.percentile = percentile.clamp(0.0, 1.0);
-        self
-    }
-}
-
-impl Default for LatencyOptimizedStrategy {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[async_trait]
-impl RoutingStrategy for LatencyOptimizedStrategy {
-    async fn evaluate(
-        &self,
-        _ctx: &RequestContext,
-        _request: &RequestDescriptor,
-        candidates: Vec<SinkCandidate>,
-    ) -> Result<Vec<ScoredRoute>> {
-        let mut scored = Vec::new();
-
-        // Find the minimum latency for normalization
-        let min_latency = candidates
-            .iter()
-            .filter_map(|c| c.health.latency_ms)
-            .min()
-            .unwrap_or(0);
-
-        for candidate in candidates {
-            let latency_ms = candidate.health.latency_ms.unwrap_or(1000); // Default to 1s if unknown
-            let latency = Duration::from_millis(latency_ms);
-
-            // Skip if over max latency threshold
-            if let Some(max) = self.max_latency
-                && latency > max
-            {
-                continue;
-            }
-
-            // Calculate latency score (lower latency = higher score)
-            let latency_score = if latency_ms > 0 {
-                // Normalize to 0-1 range, with exponential decay
-                let normalized = (min_latency as f64) / (latency_ms as f64);
-                normalized.powf(2.0) // Square to heavily favor lower latencies
-            } else {
-                1.0
-            };
-
-            // Factor in health
-            let health_factor = if candidate.health.healthy {
-                1.0 - (candidate.health.error_rate as f64 * 0.5) // Error rate impacts score
-            } else {
-                0.1 // Severely penalize unhealthy sinks
-            };
-
-            // Consider protocol conversion overhead
-            let conversion_penalty = if candidate.needs_conversion.is_some() {
-                0.95 // 5% penalty for needing conversion
-            } else {
-                1.0
-            };
-
-            let final_score = latency_score * health_factor * conversion_penalty;
-
-            scored.push(ScoredRoute {
-                sink_id: candidate.description.id.clone(),
-                score: final_score,
-                estimated_cost: None,
-                estimated_latency: Some(latency),
-                conversion_needed: candidate.needs_conversion.clone(),
-                rationale: format!(
-                    "Latency-optimized: {}ms (p{:.0}), score={:.3}",
-                    latency_ms,
-                    self.percentile * 100.0,
-                    final_score
-                ),
-            });
-        }
-
-        // Sort by score (highest first)
-        scored.sort_by(|a, b| {
-            b.score
-                .partial_cmp(&a.score)
-                .unwrap_or(std::cmp::Ordering::Equal)
-        });
-
-        Ok(scored)
-    }
-}
diff --git a/crates/core/src/router/strategy/mod.rs b/crates/core/src/router/strategy/mod.rs
deleted file mode 100644
index 0cfbf62e..00000000
--- a/crates/core/src/router/strategy/mod.rs
+++ /dev/null
@@ -1,163 +0,0 @@
-//! Routing strategy implementations
-
-mod best_of_n;
-mod cost;
-mod latency;
-mod provider_affinity;
-mod weighted;
-
-pub use best_of_n::{BestOfNStrategy, SelectionMethod};
-pub use cost::CostOptimizedStrategy;
-pub use latency::LatencyOptimizedStrategy;
-pub use provider_affinity::ProviderAffinityStrategy;
-pub use weighted::WeightedStrategy;
-
-use super::protocols::ProtocolConversion;
-use super::sink::{RequestContext, Sink, SinkDescription};
-use super::types::{RequestDescriptor, SinkHealth};
-use crate::Result;
-use async_trait::async_trait;
-use rust_decimal::Decimal;
-use std::sync::Arc;
-use std::time::Duration;
-
-/// Candidate sink for routing
-#[derive(Clone)]
-pub struct SinkCandidate {
-    pub sink: Arc<dyn Sink>,
-    pub description: SinkDescription,
-    pub health: SinkHealth,
-    pub needs_conversion: Option<ProtocolConversion>,
-}
-
-/// Scored route after strategy evaluation
-pub struct ScoredRoute {
-    pub sink_id: String,
-    pub score: f64,
-    pub estimated_cost: Option<Decimal>,
-    pub estimated_latency: Option<Duration>,
-    pub conversion_needed: Option<ProtocolConversion>,
-    pub rationale: String,
-}
-
-/// Trait for routing strategies
-#[async_trait]
-pub trait RoutingStrategy: Send + Sync {
-    /// Evaluate candidates and return scored routes
-    async fn evaluate(
-        &self,
-        ctx: &RequestContext,
-        request: &RequestDescriptor,
-        candidates: Vec<SinkCandidate>,
-    ) -> Result<Vec<ScoredRoute>>;
-}
-
-/// Simple strategy that returns candidates in order
-pub struct SimpleStrategy;
-
-impl SimpleStrategy {
-    pub fn new() -> Self {
-        Self
-    }
-}
-
-#[async_trait]
-impl RoutingStrategy for SimpleStrategy {
-    async fn evaluate(
-        &self,
-        _ctx: &RequestContext,
-        _request: &RequestDescriptor,
-        candidates: Vec<SinkCandidate>,
-    ) -> Result<Vec<ScoredRoute>> {
-        Ok(candidates
-            .into_iter()
-            .enumerate()
-            .map(|(i, candidate)| ScoredRoute {
-                sink_id: candidate.description.id,
-                score: 1.0 / (i as f64 + 1.0), // Decreasing scores
-                estimated_cost: None,
-                estimated_latency: None,
-                conversion_needed: candidate.needs_conversion,
-                rationale: "Simple ordered routing".to_string(),
-            })
-            .collect())
-    }
-}
-
-impl Default for SimpleStrategy {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-/// Composite strategy that combines multiple strategies
-pub struct CompositeStrategy {
-    strategies: Vec<(Box<dyn RoutingStrategy>, f64)>, // Strategy and weight
-}
-
-impl CompositeStrategy {
-    pub fn new(strategies: Vec<(Box<dyn RoutingStrategy>, f64)>) -> Self {
-        Self { strategies }
-    }
-}
-
-#[async_trait]
-impl RoutingStrategy for CompositeStrategy {
-    async fn evaluate(
-        &self,
-        ctx: &RequestContext,
-        request: &RequestDescriptor,
-        candidates: Vec<SinkCandidate>,
-    ) -> Result<Vec<ScoredRoute>> {
-        if self.strategies.is_empty() {
-            return Ok(vec![]);
-        }
-
-        // Collect scores from all strategies
-        let mut all_scores: std::collections::HashMap<String, Vec<(f64, f64)>> =
-            std::collections::HashMap::new();
-        let mut final_routes: std::collections::HashMap<String, ScoredRoute> =
-            std::collections::HashMap::new();
-
-        for (strategy, weight) in &self.strategies {
-            let scored = strategy.evaluate(ctx, request, candidates.clone()).await?;
-            for route in scored {
-                all_scores
-                    .entry(route.sink_id.clone())
-                    .or_default()
-                    .push((route.score, *weight));
-
-                // Store the route details (will be overwritten by last strategy)
-                final_routes.insert(route.sink_id.clone(), route);
-            }
-        }
-
-        // Calculate weighted average scores
-        let mut result = Vec::new();
-        for (sink_id, scores) in all_scores {
-            let total_weight: f64 = scores.iter().map(|(_, w)| w).sum();
-            let weighted_sum: f64 = scores.iter().map(|(s, w)| s * w).sum();
-            let final_score = if total_weight > 0.0 {
-                weighted_sum / total_weight
-            } else {
-                0.0
-            };
-
-            if let Some(mut route) = final_routes.remove(&sink_id) {
-                route.score = final_score;
-                route.rationale =
-                    format!("Composite score from {} strategies", self.strategies.len());
-                result.push(route);
-            }
-        }
-
-        // Sort by score (highest first)
-        result.sort_by(|a, b| {
-            b.score
-                .partial_cmp(&a.score)
-                .unwrap_or(std::cmp::Ordering::Equal)
-        });
-
-        Ok(result)
-    }
-}
diff --git a/crates/core/src/router/strategy/provider_affinity.rs b/crates/core/src/router/strategy/provider_affinity.rs
deleted file mode 100644
index d0afb0a6..00000000
--- a/crates/core/src/router/strategy/provider_affinity.rs
+++ /dev/null
@@ -1,127 +0,0 @@
-use super::{RoutingStrategy, ScoredRoute, SinkCandidate};
-use crate::Result;
-use crate::router::signals::{has_anthropic_signal, has_openai_signal};
-use crate::router::sink::RequestContext;
-use crate::router::types::{Protocol, RequestDescriptor};
-use async_trait::async_trait;
-use http::header::AUTHORIZATION;
-
-pub struct ProviderAffinityStrategy;
-
-impl Default for ProviderAffinityStrategy {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl ProviderAffinityStrategy {
-    pub fn new() -> Self {
-        Self
-    }
-
-    fn provider_prefix_for_model(model: &str) -> Option<&'static str> {
-        let m = model.to_lowercase();
-        if m.starts_with("claude") {
-            Some("provider://anthropic")
-        } else if m.starts_with("gpt-") || m.starts_with("o1-") || m.starts_with("o3-") {
-            Some("provider://openai")
-        } else {
-            None
-        }
-    }
-
-    fn provider_prefix_for_protocol(proto: Protocol) -> Option<&'static str> {
-        match proto {
-            Protocol::Anthropic => Some("provider://anthropic"),
-            Protocol::OpenAIChat
-            | Protocol::OpenAIMessages
-            | Protocol::OpenAICompletions
-            | Protocol::OpenAIResponses => Some("provider://openai"),
-            _ => None,
-        }
-    }
-
-    fn provider_prefix_from_headers(headers: &http::HeaderMap) -> Option<&'static str> {
-        if has_anthropic_signal(headers) {
-            return Some("provider://anthropic");
-        }
-        if has_openai_signal(headers) {
-            return Some("provider://openai");
-        }
-
-        None
-    }
-}
-
-#[async_trait]
-impl RoutingStrategy for ProviderAffinityStrategy {
-    async fn evaluate(
-        &self,
-        _ctx: &RequestContext,
-        request: &RequestDescriptor,
-        candidates: Vec<SinkCandidate>,
-    ) -> Result<Vec<ScoredRoute>> {
-        // Derive intent from protocol, headers, then model prefix as weak hint
-        let protocol_intent = Self::provider_prefix_for_protocol(request.protocol);
-        let header_intent = Self::provider_prefix_from_headers(&_ctx.headers);
-        let model_hint = Self::provider_prefix_for_model(&request.model);
-
-        let mut routes = Vec::with_capacity(candidates.len());
-        for (i, c) in candidates.into_iter().enumerate() {
-            let mut score = 0.0;
-            if let Some(p) = protocol_intent
-                && c.description.id.starts_with(p)
-            {
-                score += 1.0;
-            }
-            if let Some(h) = header_intent
-                && c.description.id.starts_with(h)
-            {
-                score += 0.6;
-            }
-            if let Some(m) = model_hint
-                && c.description.id.starts_with(m)
-            {
-                score += 0.3;
-            }
-            // Prefer Codex backend for OpenAI Responses when using OAuth (non sk- token)
-            if request.protocol == Protocol::OpenAIResponses
-                && let Some(auth) = _ctx
-                    .headers
-                    .get(AUTHORIZATION)
-                    .and_then(|v| v.to_str().ok())
-                && let Some(token) = auth.strip_prefix("Bearer ")
-                && !token.starts_with("sk-")
-                && c.description.id.starts_with("provider://openai/codex")
-            {
-                score += 0.5;
-            }
-            // Slight preference for configured/self sinks when otherwise tied
-            if c.description.id.starts_with("self://") {
-                score += 0.1;
-            }
-            // Ensure stable ordering when all signals are absent
-            if score == 0.0 {
-                score = 1.0 / (i as f64 + 1.0);
-            }
-
-            routes.push(ScoredRoute {
-                sink_id: c.description.id.clone(),
-                score,
-                estimated_cost: None,
-                estimated_latency: None,
-                conversion_needed: c.needs_conversion,
-                rationale: "Provider affinity".into(),
-            });
-        }
-
-        // Sort by score (highest first)
-        routes.sort_by(|a, b| {
-            b.score
-                .partial_cmp(&a.score)
-                .unwrap_or(std::cmp::Ordering::Equal)
-        });
-
-        Ok(routes)
-    }
-}
diff --git a/crates/core/src/router/strategy/weighted.rs b/crates/core/src/router/strategy/weighted.rs
deleted file mode 100644
index 5930c0da..00000000
--- a/crates/core/src/router/strategy/weighted.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-//! Weighted routing strategy
-
-use super::{RoutingStrategy, ScoredRoute, SinkCandidate};
-use crate::Result;
-use crate::router::sink::RequestContext;
-use crate::router::types::RequestDescriptor;
-use async_trait::async_trait;
-use std::collections::HashMap;
-
-/// Weighted routing strategy
-pub struct WeightedStrategy {
-    weights: HashMap<String, f64>,
-    randomize: bool,
-}
-
-impl WeightedStrategy {
-    /// Create a new weighted strategy
-    pub fn new(weights: HashMap<String, f64>) -> Self {
-        Self {
-            weights,
-            randomize: true,
-        }
-    }
-
-    /// Create a deterministic weighted strategy (no randomization)
-    pub fn deterministic(weights: HashMap<String, f64>) -> Self {
-        Self {
-            weights,
-            randomize: false,
-        }
-    }
-}
-
-#[async_trait]
-impl RoutingStrategy for WeightedStrategy {
-    async fn evaluate(
-        &self,
-        _ctx: &RequestContext,
-        _request: &RequestDescriptor,
-        candidates: Vec<SinkCandidate>,
-    ) -> Result<Vec<ScoredRoute>> {
-        let mut scored = Vec::new();
-
-        for candidate in candidates {
-            let sink_id = &candidate.description.id;
-            let base_weight = self.weights.get(sink_id).copied().unwrap_or(1.0);
-
-            // Adjust weight based on health
-            let health_factor = if candidate.health.healthy {
-                1.0 - candidate.health.error_rate as f64
-            } else {
-                0.1 // Severely penalize unhealthy sinks
-            };
-
-            let score = if self.randomize {
-                // Add some randomization for load balancing
-                let random_factor = 0.8 + (rand::random::<f64>() * 0.4);
-                base_weight * health_factor * random_factor
-            } else {
-                base_weight * health_factor
-            };
-
-            scored.push(ScoredRoute {
-                sink_id: sink_id.clone(),
-                score,
-                estimated_cost: None,
-                estimated_latency: candidate.health.latency_ms.map(Duration::from_millis),
-                conversion_needed: candidate.needs_conversion.clone(),
-                rationale: format!(
-                    "Weighted routing: base_weight={base_weight:.2}, health_factor={health_factor:.2}"
-                ),
-            });
-        }
-
-        // Sort by score (highest first)
-        scored.sort_by(|a, b| {
-            b.score
-                .partial_cmp(&a.score)
-                .unwrap_or(std::cmp::Ordering::Equal)
-        });
-
-        Ok(scored)
-    }
-}
-
-// Helper for random number generation in WASM
-#[cfg(target_arch = "wasm32")]
-mod rand {
-    pub fn random<T>() -> T
-    where
-        T: RandomValue,
-    {
-        T::random()
-    }
-
-    pub trait RandomValue {
-        fn random() -> Self;
-    }
-
-    impl RandomValue for f64 {
-        fn random() -> Self {
-            // Simple pseudo-random for WASM
-            let timestamp = js_sys::Date::now();
-            ((timestamp as u64 * 1103515245 + 12345) % (1 << 31)) as f64 / (1 << 31) as f64
-        }
-    }
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-mod rand {
-    use rand::{
-        Rng,
-        distributions::{Distribution, Standard},
-    };
-
-    pub fn random<T>() -> T
-    where
-        Standard: Distribution<T>,
-    {
-        rand::thread_rng().r#gen::<T>()
-    }
-}
-
-use std::time::Duration;
diff --git a/crates/core/src/router/tests.rs b/crates/core/src/router/tests.rs
deleted file mode 100644
index 23f932c5..00000000
--- a/crates/core/src/router/tests.rs
+++ /dev/null
@@ -1,445 +0,0 @@
-//! Tests for the router module
-
-use super::*;
-use crate::Result;
-use crate::state::StateBackend;
-use async_trait::async_trait;
-
-// Mock state backend for testing
-struct MockStateBackend;
-
-#[async_trait]
-impl StateBackend for MockStateBackend {
-    async fn get_user(&self, _user_id: &str) -> Result<Option<crate::User>> {
-        Ok(None)
-    }
-
-    async fn get_user_by_id(&self, _user_id: &str) -> Result<Option<crate::User>> {
-        Ok(None)
-    }
-
-    async fn create_user(&self, _user: &crate::User) -> Result<()> {
-        Ok(())
-    }
-
-    async fn update_user(&self, _user: &crate::User) -> Result<()> {
-        Ok(())
-    }
-
-    async fn delete_user(&self, _user_id: &str) -> Result<()> {
-        Ok(())
-    }
-
-    async fn list_users(&self) -> Result<Vec<crate::User>> {
-        Ok(vec![])
-    }
-
-    async fn get_api_key(&self, _key_hash: &str) -> Result<Option<crate::ApiKey>> {
-        Ok(None)
-    }
-
-    async fn create_api_key(&self, _key: &crate::ApiKey, _raw_key: &str) -> Result<()> {
-        Ok(())
-    }
-
-    async fn list_api_keys(&self, _org_id: &str) -> Result<Vec<crate::ApiKey>> {
-        Ok(vec![])
-    }
-
-    async fn delete_api_key(&self, _key_hash: &str) -> Result<()> {
-        Ok(())
-    }
-
-    async fn record_usage(&self, _usage: &crate::UsageRecord) -> Result<()> {
-        Ok(())
-    }
-
-    async fn get_usage(
-        &self,
-        _org_id: &str,
-        _range: &crate::TimeRange,
-    ) -> Result<Vec<crate::UsageRecord>> {
-        Ok(vec![])
-    }
-
-    async fn get_provider(&self, _id: &str) -> Result<Option<crate::Provider>> {
-        Ok(None)
-    }
-
-    async fn list_providers(&self) -> Result<Vec<crate::Provider>> {
-        Ok(vec![])
-    }
-
-    async fn get_model(&self, _id: &str) -> Result<Option<crate::Model>> {
-        Ok(None)
-    }
-
-    async fn list_models(&self) -> Result<Vec<crate::Model>> {
-        Ok(vec![])
-    }
-
-    async fn get_organization(&self, _id: &str) -> Result<Option<crate::Organization>> {
-        Ok(None)
-    }
-
-    async fn create_organization(&self, _org: &crate::Organization) -> Result<()> {
-        Ok(())
-    }
-
-    async fn has_permission(
-        &self,
-        _subject_id: &str,
-        _action: &crate::access::Action,
-        _object: &crate::access::ObjectIdentity,
-    ) -> Result<bool> {
-        Ok(true)
-    }
-
-    async fn grant_permission(
-        &self,
-        _subject_id: &str,
-        _action: &crate::access::Action,
-        _object: &crate::access::ObjectIdentity,
-    ) -> Result<()> {
-        Ok(())
-    }
-
-    async fn remove_permission(
-        &self,
-        _subject_id: &str,
-        _action: &crate::access::Action,
-        _object: &crate::access::ObjectIdentity,
-    ) -> Result<()> {
-        Ok(())
-    }
-
-    async fn list_user_permissions(
-        &self,
-        _user_id: &str,
-    ) -> Result<Vec<(String, String, chrono::DateTime<chrono::Utc>)>> {
-        Ok(vec![])
-    }
-}
-
-#[tokio::test]
-async fn test_router_creation() {
-    let backend = std::sync::Arc::new(MockStateBackend);
-    let registry = std::sync::Arc::new(super::registry::SinkRegistry::new());
-
-    let router = routing::Router::builder()
-        .state_backend(backend as std::sync::Arc<dyn crate::StateBackend>)
-        .sink_registry(registry)
-        .build();
-
-    // Test that router implements Sink
-    let _sink: &dyn Sink = &router;
-}
-
-#[test]
-fn test_protocol_conversion() {
-    use serde_json::json;
-
-    let openai_request = json!({
-        "model": "gpt-4",
-        "messages": [
-            {"role": "system", "content": "You are helpful"},
-            {"role": "user", "content": "Hello"}
-        ],
-        "temperature": 0.7
-    });
-
-    let (converted, warnings) =
-        protocols::convert_request(Protocol::OpenAIChat, Protocol::Anthropic, &openai_request)
-            .unwrap();
-
-    assert!(converted.get("messages").is_some());
-    assert!(converted.get("system").is_some());
-    assert_eq!(converted["system"], "You are helpful");
-    assert!(warnings.is_empty() || !warnings.is_empty()); // Either case is fine for now
-}
-
-#[tokio::test]
-async fn test_route_and_execute_with_mock_sink() {
-    use crate::access::SubjectIdentity;
-    use crate::router::index::SinkIndex;
-    use crate::router::sink::RouterIdentityContext;
-    use crate::router::sinks::mock::MockSink;
-    use crate::router::types::{RequestCapabilities, RequestDescriptor};
-    use futures::StreamExt;
-    use serde_json::json;
-
-    // Backend and registry
-    let backend = std::sync::Arc::new(MockStateBackend);
-    let registry = std::sync::Arc::new(super::registry::SinkRegistry::new());
-    registry
-        .register(
-            "self://mock".to_string(),
-            std::sync::Arc::new(MockSink::success("self://mock")),
-        )
-        .await;
-
-    // Prepare sink index snapshot for fast routing
-    let index = std::sync::Arc::new(SinkIndex::new());
-    let sink = registry.get("self://mock").await.unwrap();
-    let desc = sink.describe().await;
-    let health = sink.probe().await;
-    index
-        .set_snapshot("self://mock".to_string(), desc, health)
-        .await;
-
-    // Router
-    let router = routing::Router::builder()
-        .state_backend(backend as std::sync::Arc<dyn crate::StateBackend>)
-        .sink_registry(registry)
-        .sink_index(index)
-        .build();
-
-    // Context and descriptor
-    let ctx = sink::RequestContext {
-        identity: SubjectIdentity::new(
-            "user-1",
-            "test",
-            RouterIdentityContext {
-                org_id: Some("org-1".into()),
-                user_id: Some("user-1".into()),
-                api_key_hash: None,
-            },
-        ),
-        correlation_id: crate::tracing::CorrelationId::new(),
-        headers: Default::default(),
-        query: None,
-        trace_id: None,
-        metadata: Default::default(),
-    };
-
-    let desc = RequestDescriptor {
-        model: "test-model".into(),
-        protocol: Protocol::OpenAIChat,
-        capabilities: RequestCapabilities {
-            needs_tools: false,
-            needs_vision: false,
-            needs_streaming: false,
-            max_tokens: Some(64),
-            modalities: vec!["text".into()],
-        },
-        context_length_hint: Some(100),
-    };
-
-    // Request stream (single event)
-    let request_json = json!({
-        "model": "test-model",
-        "messages": [{"role":"user","content":"hello"}],
-        "stream": false
-    });
-    let request_stream: types::RequestStream = types::RequestStream::new(
-        Protocol::OpenAIChat,
-        Box::pin(futures::stream::once(
-            async move { Ok(request_json.clone()) },
-        )),
-    );
-
-    // Route and execute
-    let plan = router.route(&ctx, &desc).await.expect("route ok");
-    let mut response = router
-        .execute(plan, request_stream)
-        .await
-        .expect("execute ok");
-
-    // Collect chunks
-    let mut chunks = Vec::new();
-    while let Some(item) = response.next().await {
-        chunks.push(item.expect("chunk ok"));
-    }
-
-    assert!(matches!(chunks.first(), Some(ResponseChunk::Headers(_))));
-    match chunks.get(1) {
-        Some(ResponseChunk::Content(v)) => {
-            assert_eq!(v["ok"], json!(true));
-            assert!(v["echo"].is_array());
-        }
-        other => panic!("unexpected content chunk: {other:?}"),
-    }
-    assert!(matches!(
-        chunks.last(),
-        Some(ResponseChunk::Stop {
-            reason: StopReason::Complete,
-            ..
-        })
-    ));
-}
-
-#[tokio::test]
-async fn test_service_route_and_execute_json() {
-    use crate::access::SubjectIdentity;
-    use crate::router::index::SinkIndex;
-    use crate::router::service::route_and_execute_json_with_protocol;
-    use crate::router::sink::RouterIdentityContext;
-    use crate::router::sinks::mock::MockSink;
-    use crate::router::types::Protocol;
-    use futures::StreamExt;
-    use serde_json::json;
-
-    let backend = std::sync::Arc::new(MockStateBackend);
-    let registry = std::sync::Arc::new(super::registry::SinkRegistry::new());
-    registry
-        .register(
-            "self://mock".into(),
-            std::sync::Arc::new(MockSink::success("self://mock")),
-        )
-        .await;
-
-    let index = std::sync::Arc::new(SinkIndex::new());
-    index.refresh_from_registry(&registry).await;
-
-    let router = routing::Router::builder()
-        .state_backend(backend as std::sync::Arc<dyn crate::StateBackend>)
-        .sink_registry(registry)
-        .sink_index(index)
-        .build();
-
-    let ctx = sink::RequestContext {
-        identity: SubjectIdentity::new(
-            "user-1",
-            "test",
-            RouterIdentityContext {
-                org_id: None,
-                user_id: None,
-                api_key_hash: None,
-            },
-        ),
-        correlation_id: crate::tracing::CorrelationId::new(),
-        headers: Default::default(),
-        query: None,
-        trace_id: None,
-        metadata: Default::default(),
-    };
-
-    let json_req = json!({
-        "model": "m",
-        "messages": [{"role":"user","content":"hi"}],
-        "stream": false
-    });
-
-    let mut resp =
-        route_and_execute_json_with_protocol(&router, &ctx, Protocol::OpenAIChat, json_req)
-            .await
-            .expect("exec");
-    let mut chunks = Vec::new();
-    while let Some(item) = resp.next().await {
-        chunks.push(item.expect("ok"));
-    }
-    assert!(matches!(chunks.first(), Some(ResponseChunk::Headers(_))));
-    assert!(matches!(chunks.last(), Some(ResponseChunk::Stop { .. })));
-}
-
-#[tokio::test]
-async fn test_sink_index_selects_healthy_candidate() {
-    use crate::access::SubjectIdentity;
-    use crate::router::index::SinkIndex;
-    use crate::router::sink::RouterIdentityContext;
-    use crate::router::sinks::mock::MockSink;
-    use crate::router::types::{RequestCapabilities, RequestDescriptor};
-
-    let backend = std::sync::Arc::new(MockStateBackend);
-    let registry = std::sync::Arc::new(super::registry::SinkRegistry::new());
-
-    // Two sinks: A healthy, B unhealthy
-    let sink_a_id = "self://a";
-    let sink_b_id = "self://b";
-    registry
-        .register(
-            sink_a_id.to_string(),
-            std::sync::Arc::new(MockSink::success(sink_a_id)),
-        )
-        .await;
-    registry
-        .register(
-            sink_b_id.to_string(),
-            std::sync::Arc::new(MockSink::unhealthy(sink_b_id)),
-        )
-        .await;
-
-    // Build index snapshots
-    let index = std::sync::Arc::new(SinkIndex::new());
-    // Refresh from registry to populate index for all sinks
-    let refreshed = index.refresh_from_registry(&registry).await;
-    assert_eq!(refreshed, 2);
-
-    // Router with index and deterministic weighted strategy
-    use crate::router::strategy::WeightedStrategy;
-    let weights = std::collections::HashMap::new();
-    let strategy = Box::new(WeightedStrategy::deterministic(weights));
-    let router = routing::Router::builder()
-        .state_backend(backend as std::sync::Arc<dyn crate::StateBackend>)
-        .sink_registry(registry)
-        .sink_index(index)
-        .strategy(strategy)
-        .build();
-
-    let ctx = sink::RequestContext {
-        identity: SubjectIdentity::new(
-            "user-1",
-            "test",
-            RouterIdentityContext {
-                org_id: None,
-                user_id: None,
-                api_key_hash: None,
-            },
-        ),
-        correlation_id: crate::tracing::CorrelationId::new(),
-        headers: Default::default(),
-        query: None,
-        trace_id: None,
-        metadata: Default::default(),
-    };
-
-    let desc = RequestDescriptor {
-        model: "test".into(),
-        protocol: Protocol::OpenAIChat,
-        capabilities: RequestCapabilities {
-            needs_tools: false,
-            needs_vision: false,
-            needs_streaming: false,
-            max_tokens: Some(32),
-            modalities: vec!["text".into()],
-        },
-        context_length_hint: Some(64),
-    };
-
-    let plan = router.route(&ctx, &desc).await.expect("route ok");
-    assert_eq!(plan.primary_route.sink_id, sink_a_id);
-}
-
-#[tokio::test]
-async fn test_sink_index_refresher_lists_all_sinks() {
-    use crate::router::index::SinkIndex;
-    use crate::router::sinks::mock::MockSink;
-
-    let registry = std::sync::Arc::new(super::registry::SinkRegistry::new());
-    registry
-        .register(
-            "self://one".into(),
-            std::sync::Arc::new(MockSink::success("self://one")),
-        )
-        .await;
-    registry
-        .register(
-            "self://two".into(),
-            std::sync::Arc::new(MockSink::unhealthy("self://two")),
-        )
-        .await;
-
-    let index = SinkIndex::new();
-    let n = index.refresh_from_registry(&registry).await;
-    assert_eq!(n, 2);
-
-    let items = index.list().await;
-    assert_eq!(items.len(), 2);
-    // Confirm that both sink_ids are present and snapshot health matches probes
-    let mut map = std::collections::HashMap::new();
-    for (id, snap) in items {
-        map.insert(id, snap);
-    }
-    assert!(map.get("self://one").unwrap().health.healthy);
-    assert!(!map.get("self://two").unwrap().health.healthy);
-}
diff --git a/crates/core/src/router/types.rs b/crates/core/src/router/types.rs
deleted file mode 100644
index 2da66d52..00000000
--- a/crates/core/src/router/types.rs
+++ /dev/null
@@ -1,254 +0,0 @@
-//! Core types for the router module
-
-use futures::Stream;
-use rust_decimal::Decimal;
-use serde::{Deserialize, Serialize};
-use serde_json::Value as JsonValue;
-use std::collections::HashMap;
-use std::pin::Pin;
-use std::time::Duration;
-
-/// Protocol identifier for different LLM APIs
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub enum Protocol {
-    OpenAIMessages,    // v1/chat/messages
-    OpenAIChat,        // v1/chat/completions
-    OpenAICompletions, // v1/completions
-    OpenAIResponses,   // v1/responses
-    Anthropic,         // v1/messages
-    Unknown,           // Escape hatch
-}
-
-impl std::fmt::Display for Protocol {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Protocol::OpenAIMessages => write!(f, "OpenAI Messages"),
-            Protocol::OpenAIChat => write!(f, "OpenAI Chat"),
-            Protocol::OpenAICompletions => write!(f, "OpenAI Completions"),
-            Protocol::OpenAIResponses => write!(f, "OpenAI Responses"),
-            Protocol::Anthropic => write!(f, "Anthropic"),
-            Protocol::Unknown => write!(f, "Unknown"),
-        }
-    }
-}
-
-/// Sink health information
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct SinkHealth {
-    pub healthy: bool,
-    pub latency_ms: Option<u64>,
-    pub error_rate: f32,
-    pub last_error: Option<String>,
-    pub last_check: chrono::DateTime<chrono::Utc>,
-}
-
-/// Virtual model definition for user-defined routing
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct VirtualModel {
-    pub name: String,
-    pub version: String,
-    pub owner: String,
-    pub routing_rules: RoutingRules,
-    pub visibility: Visibility,
-}
-
-/// Routing rules for virtual models
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RoutingRules {
-    pub strategy: String,
-    pub targets: Vec<RoutingTarget>,
-    pub fallback: Option<Box<RoutingRules>>,
-    pub constraints: Option<RoutingConstraints>,
-}
-
-/// Target for routing
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RoutingTarget {
-    pub model: String,
-    pub weight: Option<f64>,
-    pub priority: Option<u32>,
-    pub constraints: Option<RoutingConstraints>,
-}
-
-/// Constraints for routing decisions
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RoutingConstraints {
-    pub max_cost: Option<Decimal>,
-    pub max_latency_ms: Option<u64>,
-    pub required_capabilities: Option<Vec<String>>,
-    pub excluded_providers: Option<Vec<String>>,
-}
-
-/// Visibility of virtual models
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum Visibility {
-    Public,
-    Private,
-    Organization(String),
-}
-
-/// Model capabilities
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ModelCapabilities {
-    pub context_length: usize,
-    pub supports_tools: bool,
-    pub supports_vision: bool,
-    pub supports_streaming: bool,
-    pub modalities: Vec<String>,
-}
-
-/// Sink capabilities
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct SinkCapabilities {
-    pub supports_streaming: bool,
-    pub supports_batching: bool,
-    pub supports_tools: bool,
-    pub max_context_length: Option<usize>,
-    pub modalities: Vec<String>,
-}
-
-/// Actual cost from execution
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ActualCost {
-    pub input_tokens: u32,
-    pub output_tokens: u32,
-    pub input_cost_usd: Decimal,
-    pub output_cost_usd: Decimal,
-    pub total_cost_usd: Decimal,
-    pub cached_input_tokens: Option<u32>,
-    pub provider_metadata: HashMap<String, JsonValue>,
-}
-
-/// Response chunk for streaming
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum ResponseChunk {
-    /// Response headers (optional first chunk)
-    Headers(HashMap<String, String>),
-    /// Protocol-agnostic content
-    Content(JsonValue),
-    Usage {
-        prompt_tokens: u32,
-        completion_tokens: u32,
-    },
-    Metadata(HashMap<String, JsonValue>),
-    Stop {
-        reason: StopReason,
-        error: Option<String>,
-        /// Final accumulated cost if available
-        cost: Option<ActualCost>,
-    },
-}
-
-/// Reason for stopping generation
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum StopReason {
-    Complete,
-    MaxTokens,
-    StopSequence(String),
-    ToolUse,
-    Error,
-    Cancelled,
-    Timeout,
-}
-
-/// Cost structure for a sink
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct CostStructure {
-    pub input_cost_per_token: Decimal,
-    pub output_cost_per_token: Decimal,
-    pub cached_input_cost_per_token: Option<Decimal>,
-    pub currency: String,
-}
-
-/// List of models a sink supports
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum ModelList {
-    /// Static list of known models
-    Static(Vec<String>),
-    /// Models are discovered dynamically
-    Dynamic,
-    /// Sink accepts any model name
-    Infinite,
-}
-
-/// Retry configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RetryConfig {
-    pub max_attempts: u32,
-    pub initial_delay: Duration,
-    pub max_delay: Duration,
-    pub exponential_base: f64,
-}
-
-impl Default for RetryConfig {
-    fn default() -> Self {
-        Self {
-            max_attempts: 3,
-            initial_delay: Duration::from_millis(100),
-            max_delay: Duration::from_secs(10),
-            exponential_base: 2.0,
-        }
-    }
-}
-
-/// Quota behavior when limits are exceeded
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum QuotaBehavior {
-    /// Reject the request
-    Reject,
-    /// Allow but warn
-    WarnOnly,
-    /// Allow and track overage
-    TrackOverage,
-}
-
-/// Request capabilities extracted from the request
-#[derive(Debug, Clone)]
-pub struct RequestCapabilities {
-    pub needs_tools: bool,
-    pub needs_vision: bool,
-    pub needs_streaming: bool,
-    pub max_tokens: Option<u32>,
-    pub modalities: Vec<String>,
-}
-
-/// Stream of request items with its protocol
-pub struct RequestStream {
-    protocol: Protocol,
-    inner: Pin<Box<dyn Stream<Item = crate::Result<JsonValue>> + Send>>,
-}
-
-impl RequestStream {
-    pub fn new(
-        protocol: Protocol,
-        inner: Pin<Box<dyn Stream<Item = crate::Result<JsonValue>> + Send>>,
-    ) -> Self {
-        Self { protocol, inner }
-    }
-
-    pub fn protocol(&self) -> Protocol {
-        self.protocol
-    }
-}
-
-impl Stream for RequestStream {
-    type Item = crate::Result<JsonValue>;
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Option<Self::Item>> {
-        // Safety: we're not moving inner
-        let this = unsafe { self.get_unchecked_mut() };
-        Pin::new(&mut this.inner).poll_next(cx)
-    }
-}
-
-/// Descriptor for routing without consuming the request stream
-#[derive(Debug, Clone)]
-pub struct RequestDescriptor {
-    pub model: String,
-    pub protocol: Protocol,
-    pub capabilities: RequestCapabilities,
-    /// Optional hint of total input tokens to enforce context length
-    pub context_length_hint: Option<usize>,
-}
diff --git a/crates/core/src/state.rs b/crates/core/src/state.rs
deleted file mode 100644
index a42ccbb1..00000000
--- a/crates/core/src/state.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-use crate::{
-    ApiKey, Model, Organization, Provider, Result, TimeRange, UsageRecord, User,
-    access::{Action, ObjectIdentity},
-};
-use async_trait::async_trait;
-// serde traits not needed in this module now
-
-#[async_trait]
-pub trait StateBackend: Send + Sync {
-    // User management
-    async fn get_user(&self, user_id: &str) -> Result<Option<User>>;
-    async fn get_user_by_id(&self, user_id: &str) -> Result<Option<User>>;
-    async fn create_user(&self, user: &User) -> Result<()>;
-    async fn update_user(&self, user: &User) -> Result<()>;
-    async fn delete_user(&self, user_id: &str) -> Result<()>;
-    async fn list_users(&self) -> Result<Vec<User>>;
-
-    // API key management
-    async fn get_api_key(&self, key_hash: &str) -> Result<Option<ApiKey>>;
-    async fn create_api_key(&self, key: &ApiKey, raw_key: &str) -> Result<()>;
-    async fn list_api_keys(&self, org_id: &str) -> Result<Vec<ApiKey>>;
-    async fn delete_api_key(&self, key_hash: &str) -> Result<()>;
-
-    // Usage tracking
-    async fn record_usage(&self, usage: &UsageRecord) -> Result<()>;
-    async fn get_usage(&self, org_id: &str, range: &TimeRange) -> Result<Vec<UsageRecord>>;
-
-    // Provider management
-    async fn get_provider(&self, id: &str) -> Result<Option<Provider>>;
-    async fn list_providers(&self) -> Result<Vec<Provider>>;
-
-    // Model management
-    async fn get_model(&self, id: &str) -> Result<Option<Model>>;
-    async fn list_models(&self) -> Result<Vec<Model>>;
-
-    // Organization management
-    async fn get_organization(&self, id: &str) -> Result<Option<Organization>>;
-    async fn create_organization(&self, org: &Organization) -> Result<()>;
-
-    // Permission management
-    async fn has_permission(
-        &self,
-        subject_id: &str,
-        action: &Action,
-        object: &ObjectIdentity,
-    ) -> Result<bool>;
-
-    async fn grant_permission(
-        &self,
-        subject_id: &str,
-        action: &Action,
-        object: &ObjectIdentity,
-    ) -> Result<()>;
-
-    async fn remove_permission(
-        &self,
-        subject_id: &str,
-        action: &Action,
-        object: &ObjectIdentity,
-    ) -> Result<()>;
-
-    async fn list_user_permissions(
-        &self,
-        user_id: &str,
-    ) -> Result<Vec<(String, String, chrono::DateTime<chrono::Utc>)>>;
-
-    // Router-specific methods with default implementations
-    async fn resolve_model_alias(&self, _alias: &str) -> Result<Vec<String>> {
-        Err(crate::Error::Internal(
-            "Model alias resolution not implemented".into(),
-        ))
-    }
-
-    async fn get_virtual_model(
-        &self,
-        _name: &str,
-        _version: Option<&str>,
-    ) -> Result<Option<crate::router::types::VirtualModel>> {
-        Err(crate::Error::Internal(
-            "Virtual models not implemented".into(),
-        ))
-    }
-
-    async fn save_virtual_model(&self, _model: &crate::router::types::VirtualModel) -> Result<()> {
-        Err(crate::Error::Internal(
-            "Virtual models not implemented".into(),
-        ))
-    }
-
-    async fn update_sink_health(
-        &self,
-        _sink_id: &str,
-        _health: &crate::router::types::SinkHealth,
-    ) -> Result<()> {
-        Err(crate::Error::Internal(
-            "Sink health tracking not implemented".into(),
-        ))
-    }
-
-    async fn get_sink_health(
-        &self,
-        _sink_id: &str,
-    ) -> Result<Option<crate::router::types::SinkHealth>> {
-        Err(crate::Error::Internal(
-            "Sink health tracking not implemented".into(),
-        ))
-    }
-}
-
-// Router-specific types moved to crate::router::types
diff --git a/crates/core/src/tests/context.rs b/crates/core/src/tests/context.rs
deleted file mode 100644
index af7d70fd..00000000
--- a/crates/core/src/tests/context.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-//! Mock implementation of RequestContext for testing
-
-use crate::RequestContext;
-use async_trait::async_trait;
-use std::collections::HashMap;
-
-/// Mock implementation of RequestContext for testing
-#[derive(Clone)]
-pub struct MockRequestContext {
-    pub env_vars: HashMap<String, String>,
-    pub secrets: HashMap<String, String>,
-    pub headers: HashMap<String, String>,
-    pub url: String,
-    pub method: String,
-    pub body: Vec<u8>,
-    pub client_ip: Option<String>,
-}
-
-impl Default for MockRequestContext {
-    fn default() -> Self {
-        Self {
-            env_vars: HashMap::new(),
-            secrets: HashMap::new(),
-            headers: HashMap::new(),
-            url: "http://localhost:3000".to_string(),
-            method: "GET".to_string(),
-            body: Vec::new(),
-            client_ip: Some("127.0.0.1".to_string()),
-        }
-    }
-}
-
-#[async_trait]
-impl RequestContext for MockRequestContext {
-    async fn get_env_var(&self, key: &str) -> Option<String> {
-        self.env_vars.get(key).cloned()
-    }
-
-    async fn get_secret(&self, key: &str) -> Option<String> {
-        self.secrets.get(key).cloned()
-    }
-
-    fn get_headers(&self) -> &HashMap<String, String> {
-        &self.headers
-    }
-
-    fn get_url(&self) -> &str {
-        &self.url
-    }
-
-    fn get_method(&self) -> &str {
-        &self.method
-    }
-
-    async fn get_body(
-        &self,
-    ) -> std::result::Result<Vec<u8>, Box<dyn std::error::Error + Send + Sync>> {
-        Ok(self.body.clone())
-    }
-
-    fn get_client_ip(&self) -> Option<String> {
-        self.client_ip.clone()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[tokio::test]
-    async fn test_mock_request_context() {
-        let mut ctx = MockRequestContext::default();
-
-        // Test env vars
-        ctx.env_vars
-            .insert("TEST_VAR".to_string(), "test_value".to_string());
-        assert_eq!(
-            ctx.get_env_var("TEST_VAR").await,
-            Some("test_value".to_string())
-        );
-        assert_eq!(ctx.get_env_var("MISSING").await, None);
-
-        // Test secrets
-        ctx.secrets
-            .insert("SECRET_KEY".to_string(), "secret_value".to_string());
-        assert_eq!(
-            ctx.get_secret("SECRET_KEY").await,
-            Some("secret_value".to_string())
-        );
-
-        // Test headers
-        ctx.headers
-            .insert("Content-Type".to_string(), "application/json".to_string());
-        assert_eq!(
-            ctx.get_headers().get("Content-Type"),
-            Some(&"application/json".to_string())
-        );
-
-        // Test URL and method
-        assert_eq!(ctx.get_url(), "http://localhost:3000");
-        assert_eq!(ctx.get_method(), "GET");
-
-        // Test body
-        ctx.body = b"test body".to_vec();
-        assert_eq!(ctx.get_body().await.unwrap(), b"test body");
-
-        // Test client IP
-        assert_eq!(ctx.get_client_ip(), Some("127.0.0.1".to_string()));
-    }
-}
diff --git a/crates/core/src/tests/mod.rs b/crates/core/src/tests/mod.rs
deleted file mode 100644
index 30a76f92..00000000
--- a/crates/core/src/tests/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub mod context;
-pub mod state;
diff --git a/crates/core/src/tests/state.rs b/crates/core/src/tests/state.rs
deleted file mode 100644
index 9aa4c8d0..00000000
--- a/crates/core/src/tests/state.rs
+++ /dev/null
@@ -1,617 +0,0 @@
-//! Test harness for StateBackend implementations
-//!
-//! This module provides a comprehensive test suite that can be used to verify
-//! any implementation of the StateBackend trait. Third-party implementations
-//! can use this to ensure compliance with the expected behavior.
-
-use crate::{
-    ApiKey, Model, ModelType, Organization, Provider, ProviderType, Result, StateBackend,
-    TimeRange, UsageRecord, User,
-    access::{Action, ObjectIdentity},
-};
-use async_trait::async_trait;
-use chrono::{Duration, Utc};
-use std::{collections::HashMap, sync::Arc};
-
-/// Test suite for StateBackend implementations
-pub struct StateBackendTestSuite<B: StateBackend> {
-    backend: B,
-}
-
-impl<B: StateBackend> StateBackendTestSuite<B> {
-    /// Create a new test suite with the given backend
-    pub fn new(backend: B) -> Self {
-        Self { backend }
-    }
-
-    /// Run all tests
-    pub async fn run_all_tests(&self) -> Result<()> {
-        self.test_user_operations().await?;
-        self.test_api_key_operations().await?;
-        self.test_usage_tracking().await?;
-        self.test_provider_operations().await?;
-        self.test_model_operations().await?;
-        self.test_organization_operations().await?;
-        Ok(())
-    }
-
-    /// Test user CRUD operations
-    pub async fn test_user_operations(&self) -> Result<()> {
-        // Create test user
-        let mut metadata = HashMap::new();
-        metadata.insert("email".to_string(), "test@example.com".to_string());
-        metadata.insert("name".to_string(), "Test User".to_string());
-
-        let user = User {
-            id: format!("test-user-{}", uuid::Uuid::new_v4()),
-            name: Some("Test User".to_string()),
-            created_at: Utc::now(),
-            updated_at: Utc::now(),
-            disabled_at: None,
-            metadata: metadata.clone(),
-        };
-
-        // Test create
-        self.backend.create_user(&user).await?;
-
-        // Test read
-        let retrieved = self.backend.get_user_by_id(&user.id).await?;
-        assert!(retrieved.is_some(), "User should exist after creation");
-        let retrieved_user = retrieved.unwrap();
-        assert_eq!(retrieved_user.id, user.id);
-        assert_eq!(
-            retrieved_user.metadata.get("email"),
-            Some(&"test@example.com".to_string())
-        );
-
-        // Test update
-        let mut updated_user = retrieved_user;
-        updated_user.name = Some("Updated Name".to_string());
-        updated_user.updated_at = Utc::now();
-        self.backend.update_user(&updated_user).await?;
-
-        // Verify update
-        let updated = self.backend.get_user_by_id(&user.id).await?.unwrap();
-        assert_eq!(updated.name, Some("Updated Name".to_string()));
-
-        // Test non-existent user
-        let non_existent = self.backend.get_user_by_id("non-existent").await?;
-        assert!(non_existent.is_none());
-
-        Ok(())
-    }
-
-    /// Test API key operations
-    pub async fn test_api_key_operations(&self) -> Result<()> {
-        let org_id = format!("test-org-{}", uuid::Uuid::new_v4());
-
-        // Create organization first
-        let org = Organization {
-            id: org_id.clone(),
-            name: "Test Organization".to_string(),
-            created_at: Utc::now(),
-            settings: HashMap::new(),
-        };
-        self.backend.create_organization(&org).await?;
-
-        // Create API key
-        let key = ApiKey {
-            key_hash: format!("key-hash-{}", uuid::Uuid::new_v4()),
-            name: "Test API Key".to_string(),
-            org_id: org_id.clone(),
-            config: None,
-            created_at: Utc::now(),
-            last_used_at: None,
-        };
-
-        // Test create
-        self.backend.create_api_key(&key, "raw-key-value").await?;
-
-        // Test read
-        let retrieved = self.backend.get_api_key(&key.key_hash).await?;
-        assert!(retrieved.is_some());
-        let retrieved_key = retrieved.unwrap();
-        assert_eq!(retrieved_key.name, key.name);
-        assert_eq!(retrieved_key.org_id, key.org_id);
-
-        // Test list
-        let keys = self.backend.list_api_keys(&org_id).await?;
-        assert!(!keys.is_empty());
-        assert!(keys.iter().any(|k| k.key_hash == key.key_hash));
-
-        // Test delete
-        self.backend.delete_api_key(&key.key_hash).await?;
-        let deleted = self.backend.get_api_key(&key.key_hash).await?;
-        assert!(deleted.is_none());
-
-        Ok(())
-    }
-
-    /// Test usage tracking
-    pub async fn test_usage_tracking(&self) -> Result<()> {
-        let org_id = format!("test-org-{}", uuid::Uuid::new_v4());
-        let user_id = format!("test-user-{}", uuid::Uuid::new_v4());
-
-        // Create multiple usage records
-        let base_time = Utc::now();
-        for i in 0..5 {
-            let usage = UsageRecord {
-                id: format!("usage-{}", uuid::Uuid::new_v4()),
-                org_id: org_id.clone(),
-                user_id: user_id.clone(),
-                api_key_hash: "test-key-hash".to_string(),
-                request_id: format!("req-{i}"),
-                provider_id: "openai".to_string(),
-                model_id: "gpt-4".to_string(),
-                input_tokens: 100 + i as u64 * 10,
-                output_tokens: 200 + i as u64 * 20,
-                total_tokens: 300 + i as u64 * 30,
-                cost: 0.01 * (i + 1) as f64,
-                timestamp: base_time - Duration::minutes(i as i64),
-                metadata: HashMap::new(),
-            };
-            self.backend.record_usage(&usage).await?;
-        }
-
-        // Test retrieval with time range
-        let range = TimeRange {
-            start: base_time - Duration::hours(1),
-            end: base_time + Duration::hours(1),
-        };
-        let records = self.backend.get_usage(&org_id, &range).await?;
-        assert_eq!(records.len(), 5);
-
-        // Verify ordering (should be descending by timestamp)
-        for i in 1..records.len() {
-            assert!(records[i - 1].timestamp >= records[i].timestamp);
-        }
-
-        // Test empty range
-        let empty_range = TimeRange {
-            start: base_time - Duration::days(10),
-            end: base_time - Duration::days(9),
-        };
-        let empty_records = self.backend.get_usage(&org_id, &empty_range).await?;
-        assert!(empty_records.is_empty());
-
-        Ok(())
-    }
-
-    /// Test provider operations
-    pub async fn test_provider_operations(&self) -> Result<()> {
-        // Note: Providers are typically pre-seeded, so we just test read operations
-        // This test assumes the backend starts empty or has a way to seed test data
-
-        // Test list providers (might be empty initially)
-        let providers = self.backend.list_providers().await?;
-
-        // If we have providers, test getting one
-        if let Some(first_provider) = providers.first() {
-            let retrieved = self.backend.get_provider(&first_provider.id).await?;
-            assert!(retrieved.is_some());
-            assert_eq!(retrieved.unwrap().id, first_provider.id);
-        }
-
-        // Test non-existent provider
-        let non_existent = self.backend.get_provider("non-existent-provider").await?;
-        assert!(non_existent.is_none());
-
-        Ok(())
-    }
-
-    /// Test model operations
-    pub async fn test_model_operations(&self) -> Result<()> {
-        // Similar to providers, models are typically pre-seeded
-        let models = self.backend.list_models().await?;
-
-        if let Some(first_model) = models.first() {
-            let retrieved = self.backend.get_model(&first_model.id).await?;
-            assert!(retrieved.is_some());
-            assert_eq!(retrieved.unwrap().id, first_model.id);
-        }
-
-        // Test non-existent model
-        let non_existent = self.backend.get_model("non-existent-model").await?;
-        assert!(non_existent.is_none());
-
-        Ok(())
-    }
-
-    /// Test organization operations
-    pub async fn test_organization_operations(&self) -> Result<()> {
-        let mut settings = HashMap::new();
-        settings.insert("tier".to_string(), "pro".to_string());
-        settings.insert("max_users".to_string(), "100".to_string());
-
-        let org = Organization {
-            id: format!("test-org-{}", uuid::Uuid::new_v4()),
-            name: "Test Organization".to_string(),
-            created_at: Utc::now(),
-            settings,
-        };
-
-        // Test create
-        self.backend.create_organization(&org).await?;
-
-        // Test read
-        let retrieved = self.backend.get_organization(&org.id).await?;
-        assert!(retrieved.is_some());
-        let retrieved_org = retrieved.unwrap();
-        assert_eq!(retrieved_org.name, org.name);
-        assert_eq!(retrieved_org.settings.get("tier"), Some(&"pro".to_string()));
-
-        // Test non-existent organization
-        let non_existent = self.backend.get_organization("non-existent").await?;
-        assert!(non_existent.is_none());
-
-        Ok(())
-    }
-}
-
-/// Helper function to create test data
-pub mod fixtures {
-    use super::*;
-
-    pub fn create_test_user(id: Option<String>) -> User {
-        let mut metadata = HashMap::new();
-        metadata.insert("email".to_string(), "test@example.com".to_string());
-        metadata.insert("name".to_string(), "Test User".to_string());
-
-        User {
-            id: id.unwrap_or_else(|| format!("user-{}", uuid::Uuid::new_v4())),
-            name: Some("Test User".to_string()),
-            created_at: Utc::now(),
-            updated_at: Utc::now(),
-            disabled_at: None,
-            metadata,
-        }
-    }
-
-    pub fn create_test_organization(id: Option<String>) -> Organization {
-        Organization {
-            id: id.unwrap_or_else(|| format!("org-{}", uuid::Uuid::new_v4())),
-            name: "Test Organization".to_string(),
-            created_at: Utc::now(),
-            settings: HashMap::new(),
-        }
-    }
-
-    pub fn create_test_api_key(org_id: String) -> ApiKey {
-        ApiKey {
-            key_hash: format!("key-{}", uuid::Uuid::new_v4()),
-            name: "Test API Key".to_string(),
-            org_id,
-            config: None,
-            created_at: Utc::now(),
-            last_used_at: None,
-        }
-    }
-
-    pub fn create_test_provider() -> Provider {
-        Provider {
-            id: format!("provider-{}", uuid::Uuid::new_v4()),
-            name: "Test Provider".to_string(),
-            provider_type: ProviderType::OpenAI,
-            config: None,
-            enabled: true,
-            priority: 0,
-        }
-    }
-
-    pub fn create_test_model(provider_id: String) -> Model {
-        Model {
-            id: format!("model-{}", uuid::Uuid::new_v4()),
-            provider_id,
-            name: "test-model".to_string(),
-            model_type: ModelType::Chat,
-            capabilities: HashMap::new(),
-            pricing_id: None,
-            pricing_config: None,
-        }
-    }
-}
-
-/// In-memory implementation of StateBackend for integration testing
-///
-/// This implementation actually stores data and behaves like a real backend,
-/// making it suitable for integration tests that need realistic behavior.
-///
-/// For unit tests that need to verify specific calls and mock errors,
-/// use the mockall-based MockStateBackend from the parent module instead.
-#[derive(Clone, Default)]
-pub struct InMemoryBackend {
-    users: Arc<std::sync::Mutex<HashMap<String, User>>>,
-    api_keys: Arc<std::sync::Mutex<HashMap<String, ApiKey>>>,
-    usage_records: Arc<std::sync::Mutex<Vec<UsageRecord>>>,
-    providers: Arc<std::sync::Mutex<HashMap<String, Provider>>>,
-    models: Arc<std::sync::Mutex<HashMap<String, Model>>>,
-    organizations: Arc<std::sync::Mutex<HashMap<String, Organization>>>,
-}
-
-#[async_trait]
-impl StateBackend for InMemoryBackend {
-    async fn get_user_by_id(&self, user_id: &str) -> Result<Option<User>> {
-        Ok(self.users.lock().unwrap().get(user_id).cloned())
-    }
-
-    async fn create_user(&self, user: &User) -> Result<()> {
-        self.users
-            .lock()
-            .unwrap()
-            .insert(user.id.clone(), user.clone());
-        Ok(())
-    }
-
-    async fn update_user(&self, user: &User) -> Result<()> {
-        self.users
-            .lock()
-            .unwrap()
-            .insert(user.id.clone(), user.clone());
-        Ok(())
-    }
-
-    async fn get_user(&self, user_id: &str) -> Result<Option<User>> {
-        self.get_user_by_id(user_id).await
-    }
-
-    async fn delete_user(&self, user_id: &str) -> Result<()> {
-        self.users.lock().unwrap().remove(user_id);
-        Ok(())
-    }
-
-    async fn list_users(&self) -> Result<Vec<User>> {
-        let mut results: Vec<_> = self.users.lock().unwrap().values().cloned().collect();
-        results.sort_by(|a, b| b.created_at.cmp(&a.created_at));
-        Ok(results)
-    }
-
-    async fn get_api_key(&self, key_hash: &str) -> Result<Option<ApiKey>> {
-        Ok(self.api_keys.lock().unwrap().get(key_hash).cloned())
-    }
-
-    async fn create_api_key(&self, key: &ApiKey, _raw_key: &str) -> Result<()> {
-        self.api_keys
-            .lock()
-            .unwrap()
-            .insert(key.key_hash.clone(), key.clone());
-        Ok(())
-    }
-
-    async fn list_api_keys(&self, org_id: &str) -> Result<Vec<ApiKey>> {
-        let mut keys: Vec<ApiKey> = self
-            .api_keys
-            .lock()
-            .unwrap()
-            .values()
-            .filter(|k| k.org_id == org_id)
-            .cloned()
-            .collect();
-
-        // Sort by created_at descending to match SQL behavior
-        keys.sort_by(|a, b| b.created_at.cmp(&a.created_at));
-
-        Ok(keys)
-    }
-
-    async fn delete_api_key(&self, key_hash: &str) -> Result<()> {
-        self.api_keys.lock().unwrap().remove(key_hash);
-        Ok(())
-    }
-
-    async fn record_usage(&self, usage: &UsageRecord) -> Result<()> {
-        self.usage_records.lock().unwrap().push(usage.clone());
-        Ok(())
-    }
-
-    async fn get_usage(&self, org_id: &str, range: &TimeRange) -> Result<Vec<UsageRecord>> {
-        let mut records: Vec<UsageRecord> = self
-            .usage_records
-            .lock()
-            .unwrap()
-            .iter()
-            .filter(|u| {
-                u.org_id == org_id && u.timestamp >= range.start && u.timestamp <= range.end
-            })
-            .cloned()
-            .collect();
-
-        // Sort by timestamp descending to match SQL behavior
-        records.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));
-
-        Ok(records)
-    }
-
-    async fn get_provider(&self, id: &str) -> Result<Option<Provider>> {
-        Ok(self.providers.lock().unwrap().get(id).cloned())
-    }
-
-    async fn list_providers(&self) -> Result<Vec<Provider>> {
-        let mut providers: Vec<Provider> = self
-            .providers
-            .lock()
-            .unwrap()
-            .values()
-            .filter(|p| p.enabled) // Only return enabled providers
-            .cloned()
-            .collect();
-
-        // Sort by name to match SQL behavior
-        providers.sort_by(|a, b| a.name.cmp(&b.name));
-
-        Ok(providers)
-    }
-
-    async fn get_model(&self, id: &str) -> Result<Option<Model>> {
-        Ok(self.models.lock().unwrap().get(id).cloned())
-    }
-
-    async fn list_models(&self) -> Result<Vec<Model>> {
-        let mut models: Vec<Model> = self.models.lock().unwrap().values().cloned().collect();
-
-        // Sort by provider_id, then name to match SQL behavior
-        models.sort_by(|a, b| match a.provider_id.cmp(&b.provider_id) {
-            std::cmp::Ordering::Equal => a.name.cmp(&b.name),
-            other => other,
-        });
-
-        Ok(models)
-    }
-
-    async fn get_organization(&self, id: &str) -> Result<Option<Organization>> {
-        Ok(self.organizations.lock().unwrap().get(id).cloned())
-    }
-
-    async fn create_organization(&self, org: &Organization) -> Result<()> {
-        self.organizations
-            .lock()
-            .unwrap()
-            .insert(org.id.clone(), org.clone());
-        Ok(())
-    }
-
-    async fn has_permission(
-        &self,
-        _subject_id: &str,
-        _action: &Action,
-        _object: &ObjectIdentity,
-    ) -> Result<bool> {
-        // For tests, just return true
-        Ok(true)
-    }
-
-    async fn grant_permission(
-        &self,
-        _subject_id: &str,
-        _action: &Action,
-        _object: &ObjectIdentity,
-    ) -> Result<()> {
-        // For tests, just return Ok
-        Ok(())
-    }
-
-    async fn remove_permission(
-        &self,
-        _subject_id: &str,
-        _action: &Action,
-        _object: &ObjectIdentity,
-    ) -> Result<()> {
-        // For tests, just return Ok
-        Ok(())
-    }
-
-    async fn list_user_permissions(
-        &self,
-        _user_id: &str,
-    ) -> Result<Vec<(String, String, chrono::DateTime<chrono::Utc>)>> {
-        // For tests, return empty list
-        Ok(Vec::new())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[tokio::test]
-    async fn test_in_memory_backend_compliance() {
-        let backend = InMemoryBackend::default();
-        let suite = StateBackendTestSuite::new(backend);
-        suite
-            .run_all_tests()
-            .await
-            .expect("InMemoryBackend should pass all tests");
-    }
-
-    #[tokio::test]
-    async fn test_in_memory_backend_time_filtering() {
-        let backend = InMemoryBackend::default();
-
-        // Create some usage records with different timestamps
-        let org_id = "test-org";
-        let base_time = Utc::now();
-
-        for i in 0..5 {
-            let usage = UsageRecord {
-                id: format!("usage-{i}"),
-                org_id: org_id.to_string(),
-                user_id: "user1".to_string(),
-                api_key_hash: "key1".to_string(),
-                request_id: format!("req-{i}"),
-                provider_id: "provider1".to_string(),
-                model_id: "model1".to_string(),
-                input_tokens: 100,
-                output_tokens: 200,
-                total_tokens: 300,
-                cost: 0.01,
-                timestamp: base_time - Duration::hours(i as i64),
-                metadata: HashMap::new(),
-            };
-            backend.record_usage(&usage).await.unwrap();
-        }
-
-        // Test range that includes only some records
-        let range = TimeRange {
-            start: base_time - Duration::hours(2),
-            end: base_time,
-        };
-
-        let records = backend.get_usage(org_id, &range).await.unwrap();
-        assert_eq!(records.len(), 3); // Should include records 0, 1, 2
-
-        // Verify they're sorted by timestamp descending
-        for i in 1..records.len() {
-            assert!(records[i - 1].timestamp >= records[i].timestamp);
-        }
-    }
-
-    #[tokio::test]
-    async fn test_in_memory_backend_provider_filtering() {
-        let backend = InMemoryBackend::default();
-
-        // Insert some providers, some enabled and some disabled
-        let providers = vec![
-            Provider {
-                id: "p1".to_string(),
-                name: "Provider B".to_string(),
-                provider_type: ProviderType::OpenAI,
-                config: None,
-                enabled: true,
-                priority: 1,
-            },
-            Provider {
-                id: "p2".to_string(),
-                name: "Provider A".to_string(),
-                provider_type: ProviderType::Anthropic,
-                config: None,
-                enabled: false, // Disabled
-                priority: 2,
-            },
-            Provider {
-                id: "p3".to_string(),
-                name: "Provider C".to_string(),
-                provider_type: ProviderType::Google,
-                config: None,
-                enabled: true,
-                priority: 3,
-            },
-        ];
-
-        for provider in providers {
-            backend
-                .providers
-                .lock()
-                .unwrap()
-                .insert(provider.id.clone(), provider);
-        }
-
-        let listed = backend.list_providers().await.unwrap();
-
-        // Should only return enabled providers
-        assert_eq!(listed.len(), 2);
-        assert!(listed.iter().all(|p| p.enabled));
-
-        // Should be sorted by name
-        assert_eq!(listed[0].name, "Provider B");
-        assert_eq!(listed[1].name, "Provider C");
-    }
-}
diff --git a/crates/core/src/tracing/config.rs b/crates/core/src/tracing/config.rs
deleted file mode 100644
index f323ba4d..00000000
--- a/crates/core/src/tracing/config.rs
+++ /dev/null
@@ -1,147 +0,0 @@
-//! Configuration for tracing and instrumentation
-//!
-//! This module provides configuration types for setting up tracing with
-//! optional OpenTelemetry export.
-
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-
-/// Main instrumentation configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct InstrumentationConfig {
-    /// Service name for tracing
-    pub service_name: String,
-    /// Service version
-    pub service_version: String,
-    /// Log level filter (e.g., "info", "debug", "trace")
-    pub log_level: String,
-    /// Optional OTLP configuration for OpenTelemetry export
-    #[serde(default)]
-    pub otlp: Option<OtlpConfig>,
-}
-
-/// OpenTelemetry Protocol (OTLP) configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct OtlpConfig {
-    /// OTLP endpoint URL
-    pub endpoint: String,
-    /// Optional headers to send with OTLP requests
-    #[serde(default)]
-    pub headers: Option<HashMap<String, String>>,
-}
-
-impl Default for InstrumentationConfig {
-    fn default() -> Self {
-        Self {
-            service_name: "gate".to_string(),
-            service_version: env!("CARGO_PKG_VERSION").to_string(),
-            log_level: "info".to_string(),
-            otlp: None,
-        }
-    }
-}
-
-impl InstrumentationConfig {
-    /// Create configuration from environment variables
-    ///
-    /// Supports the following environment variables:
-    /// - `OTEL_SERVICE_NAME` or `SERVICE_NAME`: Service name
-    /// - `OTEL_SERVICE_VERSION` or `SERVICE_VERSION`: Service version
-    /// - `RUST_LOG`: Log level filter
-    /// - `OTEL_EXPORTER_OTLP_ENDPOINT`: OTLP endpoint URL
-    /// - `OTEL_EXPORTER_OTLP_HEADERS`: Comma-separated headers (key=value)
-    pub fn from_env() -> Self {
-        let service_name = std::env::var("OTEL_SERVICE_NAME")
-            .or_else(|_| std::env::var("SERVICE_NAME"))
-            .unwrap_or_else(|_| "gate".to_string());
-
-        let service_version = std::env::var("OTEL_SERVICE_VERSION")
-            .or_else(|_| std::env::var("SERVICE_VERSION"))
-            .unwrap_or_else(|_| env!("CARGO_PKG_VERSION").to_string());
-
-        let log_level = std::env::var("RUST_LOG").unwrap_or_else(|_| "info".to_string());
-
-        let otlp = if let Ok(endpoint) = std::env::var("OTEL_EXPORTER_OTLP_ENDPOINT") {
-            let headers = std::env::var("OTEL_EXPORTER_OTLP_HEADERS")
-                .ok()
-                .and_then(|h| {
-                    let map: HashMap<String, String> = h
-                        .split(',')
-                        .filter_map(|pair| {
-                            let parts: Vec<&str> = pair.splitn(2, '=').collect();
-                            if parts.len() == 2 {
-                                Some((parts[0].to_string(), parts[1].to_string()))
-                            } else {
-                                None
-                            }
-                        })
-                        .collect();
-                    if map.is_empty() { None } else { Some(map) }
-                });
-
-            Some(OtlpConfig { endpoint, headers })
-        } else {
-            None
-        };
-
-        Self {
-            service_name,
-            service_version,
-            log_level,
-            otlp,
-        }
-    }
-
-    /// Create a development configuration with sensible defaults
-    pub fn dev() -> Self {
-        Self {
-            service_name: "gate-dev".to_string(),
-            service_version: "dev".to_string(),
-            log_level: "debug".to_string(),
-            otlp: None,
-        }
-    }
-
-    /// Create a configuration for Jaeger export
-    pub fn with_jaeger(endpoint: impl Into<String>) -> Self {
-        Self {
-            otlp: Some(OtlpConfig {
-                endpoint: endpoint.into(),
-                headers: None,
-            }),
-            ..Self::default()
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_default_config() {
-        let config = InstrumentationConfig::default();
-        assert_eq!(config.service_name, "gate");
-        assert_eq!(config.service_version, env!("CARGO_PKG_VERSION"));
-        assert_eq!(config.log_level, "info");
-        assert!(config.otlp.is_none());
-    }
-
-    #[test]
-    fn test_dev_config() {
-        let config = InstrumentationConfig::dev();
-        assert_eq!(config.service_name, "gate-dev");
-        assert_eq!(config.service_version, "dev");
-        assert_eq!(config.log_level, "debug");
-        assert!(config.otlp.is_none());
-    }
-
-    #[test]
-    fn test_with_jaeger() {
-        let config = InstrumentationConfig::with_jaeger("http://localhost:4317");
-        assert!(config.otlp.is_some());
-        let otlp = config.otlp.unwrap();
-        assert_eq!(otlp.endpoint, "http://localhost:4317");
-        assert!(otlp.headers.is_none());
-    }
-}
diff --git a/crates/core/src/tracing/correlation.rs b/crates/core/src/tracing/correlation.rs
deleted file mode 100644
index 7c02e081..00000000
--- a/crates/core/src/tracing/correlation.rs
+++ /dev/null
@@ -1,241 +0,0 @@
-//! Correlation ID for distributed tracing
-//!
-//! This module provides a correlation ID that wraps W3C TraceContext
-//! for distributed tracing while supporting legacy string-based correlation IDs.
-
-use std::{fmt, str::FromStr, sync::Arc};
-
-use crate::tracing::trace_context::{TraceContext, TraceContextError};
-
-/// A correlation ID for distributed tracing
-///
-/// This wraps the W3C TraceContext standard while maintaining compatibility
-/// with legacy string-based correlation IDs.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct CorrelationId {
-    /// The underlying W3C trace context
-    trace_context: Arc<TraceContext>,
-    /// Optional legacy correlation ID for backward compatibility
-    legacy_id: Option<String>,
-}
-
-impl CorrelationId {
-    /// Create a new correlation ID with a random trace context
-    pub fn new() -> Self {
-        Self {
-            trace_context: Arc::new(TraceContext::new()),
-            legacy_id: None,
-        }
-    }
-
-    /// Create from a string (tries to parse as traceparent first, then as legacy ID)
-    pub fn from_string(s: &str) -> Self {
-        if let Ok(ctx) = TraceContext::from_str(s) {
-            Self {
-                trace_context: Arc::new(ctx),
-                legacy_id: None,
-            }
-        } else {
-            Self::from_legacy(s)
-        }
-    }
-
-    /// Create from a W3C traceparent string
-    pub fn from_traceparent(traceparent: &str) -> Result<Self, TraceContextError> {
-        Ok(Self {
-            trace_context: Arc::new(TraceContext::from_str(traceparent)?),
-            legacy_id: None,
-        })
-    }
-
-    /// Create from a TraceContext
-    pub fn from_trace_context(ctx: TraceContext) -> Self {
-        Self {
-            trace_context: Arc::new(ctx),
-            legacy_id: None,
-        }
-    }
-
-    /// Create from a legacy correlation ID string
-    pub fn from_legacy(id: &str) -> Self {
-        // Create a deterministic trace context from the legacy ID
-        let ctx = TraceContext::from_legacy_id(id);
-        Self {
-            trace_context: Arc::new(ctx),
-            legacy_id: Some(id.to_string()),
-        }
-    }
-
-    /// Get the trace ID as a hex string
-    pub fn trace_id(&self) -> String {
-        hex::encode(self.trace_context.trace_id())
-    }
-
-    /// Get the span ID as a hex string
-    pub fn span_id(&self) -> String {
-        hex::encode(self.trace_context.span_id())
-    }
-
-    /// Get the W3C traceparent header value
-    pub fn to_traceparent(&self) -> String {
-        self.trace_context.to_string()
-    }
-
-    /// Get the underlying trace context
-    pub fn trace_context(&self) -> &TraceContext {
-        &self.trace_context
-    }
-
-    /// Convert to OpenTelemetry SpanContext
-    #[cfg(all(feature = "tracing-otlp", not(target_arch = "wasm32")))]
-    #[cfg_attr(
-        docsrs,
-        doc(cfg(all(feature = "tracing-otlp", not(target_arch = "wasm32"))))
-    )]
-    pub fn to_span_context(&self) -> opentelemetry::trace::SpanContext {
-        opentelemetry::trace::SpanContext::new(
-            opentelemetry::trace::TraceId::from_bytes(*self.trace_context.trace_id()),
-            opentelemetry::trace::SpanId::from_bytes(*self.trace_context.span_id()),
-            if self.trace_context.is_sampled() {
-                opentelemetry::trace::TraceFlags::SAMPLED
-            } else {
-                opentelemetry::trace::TraceFlags::default()
-            },
-            false,
-            opentelemetry::trace::TraceState::default(),
-        )
-    }
-
-    /// Create a child correlation ID with a new span ID
-    pub fn child(&self) -> Self {
-        Self {
-            trace_context: Arc::new(self.trace_context.child()),
-            legacy_id: self.legacy_id.clone(),
-        }
-    }
-}
-
-impl Default for CorrelationId {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl fmt::Display for CorrelationId {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // If we have a legacy ID, use that for display
-        if let Some(ref legacy) = self.legacy_id {
-            write!(f, "{legacy}")
-        } else {
-            // Otherwise use the trace ID
-            write!(f, "{}", self.trace_id())
-        }
-    }
-}
-
-impl FromStr for CorrelationId {
-    type Err = std::convert::Infallible;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(Self::from_string(s))
-    }
-}
-
-// Thread-local storage for current correlation ID (native only)
-#[cfg(not(target_arch = "wasm32"))]
-mod native {
-    use super::*;
-    use std::cell::RefCell;
-
-    thread_local! {
-        static CURRENT_CORRELATION_ID: RefCell<Option<CorrelationId>> = const { RefCell::new(None) };
-    }
-
-    /// Get the current correlation ID for this thread
-    pub fn current_correlation_id() -> Option<CorrelationId> {
-        CURRENT_CORRELATION_ID.with(|id| id.borrow().clone())
-    }
-
-    /// Set the current correlation ID for this thread
-    pub fn set_current_correlation_id(id: Option<CorrelationId>) {
-        CURRENT_CORRELATION_ID.with(|current| {
-            *current.borrow_mut() = id;
-        });
-    }
-
-    /// RAII guard for setting correlation ID in a scope
-    pub struct CorrelationScope {
-        previous: Option<CorrelationId>,
-    }
-
-    impl CorrelationScope {
-        /// Create a new correlation scope
-        pub fn new(id: CorrelationId) -> Self {
-            let previous = current_correlation_id();
-            set_current_correlation_id(Some(id));
-            Self { previous }
-        }
-    }
-
-    impl Drop for CorrelationScope {
-        fn drop(&mut self) {
-            set_current_correlation_id(self.previous.take());
-        }
-    }
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-pub use native::{CorrelationScope, current_correlation_id, set_current_correlation_id};
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_new_correlation_id() {
-        let id1 = CorrelationId::new();
-        let id2 = CorrelationId::new();
-        assert_ne!(id1, id2);
-        assert_ne!(id1.trace_id(), id2.trace_id());
-    }
-
-    #[test]
-    fn test_from_traceparent() {
-        let traceparent = "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01";
-        let id = CorrelationId::from_traceparent(traceparent).unwrap();
-        assert_eq!(id.to_traceparent(), traceparent);
-        assert_eq!(id.trace_id(), "4bf92f3577b34da6a3ce929d0e0e4736");
-        assert_eq!(id.span_id(), "00f067aa0ba902b7");
-    }
-
-    #[test]
-    fn test_from_legacy() {
-        let legacy = "my-correlation-id";
-        let id = CorrelationId::from_legacy(legacy);
-        assert_eq!(id.to_string(), legacy);
-        // Should create a deterministic trace context
-        let id2 = CorrelationId::from_legacy(legacy);
-        assert_eq!(id.trace_id(), id2.trace_id());
-    }
-
-    #[test]
-    fn test_child() {
-        let parent = CorrelationId::new();
-        let child = parent.child();
-        assert_eq!(parent.trace_id(), child.trace_id());
-        assert_ne!(parent.span_id(), child.span_id());
-    }
-
-    #[test]
-    fn test_from_string() {
-        // Should parse traceparent
-        let traceparent = "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01";
-        let id = CorrelationId::from_string(traceparent);
-        assert_eq!(id.to_traceparent(), traceparent);
-
-        // Should treat as legacy ID
-        let legacy = "not-a-traceparent";
-        let id = CorrelationId::from_string(legacy);
-        assert_eq!(id.to_string(), legacy);
-    }
-}
diff --git a/crates/core/src/tracing/init.rs b/crates/core/src/tracing/init.rs
deleted file mode 100644
index 2937a678..00000000
--- a/crates/core/src/tracing/init.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-//! Initialization functions for tracing
-//!
-//! This module provides functions to initialize the tracing subsystem
-//! with optional OpenTelemetry export.
-
-use anyhow::Result;
-use tracing_subscriber::{EnvFilter, layer::SubscriberExt, util::SubscriberInitExt};
-
-use crate::tracing::config::InstrumentationConfig;
-
-/// Initialize tracing with the given configuration
-pub fn init_tracing(config: &InstrumentationConfig) -> Result<()> {
-    // Create env filter
-    let env_filter = EnvFilter::try_from_default_env()
-        .or_else(|_| EnvFilter::try_new(&config.log_level))
-        .unwrap_or_else(|_| EnvFilter::new("info"));
-
-    // Create the base subscriber with formatting layer
-    let fmt_layer = tracing_subscriber::fmt::layer()
-        .with_target(true)
-        .with_thread_ids(true)
-        .with_thread_names(true);
-
-    // Initialize based on whether OTLP is configured
-    if let Some(otlp_config) = &config.otlp {
-        // Initialize with OTLP export
-        init_with_otlp(config, otlp_config, env_filter)?;
-    } else {
-        // Initialize without OTLP
-        tracing_subscriber::registry()
-            .with(fmt_layer)
-            .with(env_filter)
-            .init();
-    }
-
-    Ok(())
-}
-
-/// Initialize with OTLP export
-#[cfg(feature = "tracing-otlp")]
-fn init_with_otlp(
-    _config: &InstrumentationConfig,
-    otlp_config: &crate::tracing::config::OtlpConfig,
-    env_filter: EnvFilter,
-) -> Result<()> {
-    use opentelemetry::trace::TracerProvider as _;
-    use opentelemetry_otlp::WithExportConfig;
-    use opentelemetry_sdk::trace::{RandomIdGenerator, Sampler, SdkTracerProvider};
-    use tracing_opentelemetry::OpenTelemetryLayer;
-
-    // Note: In this version of OpenTelemetry, resource creation is limited
-    // We'll set service info through environment variables instead
-
-    // Create OTLP exporter
-    let exporter = opentelemetry_otlp::SpanExporter::builder()
-        .with_http()
-        .with_endpoint(&otlp_config.endpoint)
-        .build()?;
-
-    // Create tracer provider
-    let tracer_provider = SdkTracerProvider::builder()
-        .with_batch_exporter(exporter)
-        .with_sampler(Sampler::AlwaysOn)
-        .with_id_generator(RandomIdGenerator::default())
-        .build();
-
-    // Create OpenTelemetry layer
-    let otel_layer = OpenTelemetryLayer::new(tracer_provider.tracer("gate"));
-
-    // Create the formatting layer
-    let fmt_layer = tracing_subscriber::fmt::layer()
-        .with_target(true)
-        .with_thread_ids(true)
-        .with_thread_names(true);
-
-    // Initialize subscriber with all layers
-    tracing_subscriber::registry()
-        .with(fmt_layer)
-        .with(env_filter)
-        .with(otel_layer)
-        .init();
-
-    Ok(())
-}
-
-/// Initialize with OTLP export (stub for when feature is disabled)
-#[cfg(not(feature = "tracing-otlp"))]
-fn init_with_otlp(
-    _config: &InstrumentationConfig,
-    _otlp_config: &crate::tracing::config::OtlpConfig,
-    env_filter: EnvFilter,
-) -> Result<()> {
-    // Create the formatting layer
-    let fmt_layer = tracing_subscriber::fmt::layer()
-        .with_target(true)
-        .with_thread_ids(true)
-        .with_thread_names(true);
-
-    // Just initialize without OTLP when feature is disabled
-    tracing_subscriber::registry()
-        .with(fmt_layer)
-        .with(env_filter)
-        .init();
-
-    warn!("OTLP export requested but tracing-otlp feature is not enabled");
-    Ok(())
-}
-
-/// Initialize with default configuration from environment
-pub fn init_default() -> Result<()> {
-    let config = InstrumentationConfig::from_env();
-    init_tracing(&config)
-}
-
-/// Initialize with development configuration
-pub fn init_dev() -> Result<()> {
-    let config = InstrumentationConfig::dev();
-    init_tracing(&config)
-}
-
-/// Initialize with Jaeger OTLP export
-pub fn init_with_jaeger() -> Result<()> {
-    let jaeger_endpoint =
-        std::env::var("JAEGER_ENDPOINT").unwrap_or_else(|_| "http://localhost:4317".to_string());
-    let config = InstrumentationConfig::with_jaeger(jaeger_endpoint);
-    init_tracing(&config)
-}
-
-/// Shutdown OpenTelemetry providers gracefully
-pub fn shutdown_tracer_provider() {
-    // Note: In newer versions of OpenTelemetry, shutdown happens automatically
-    // when the tracer provider is dropped. We keep this function for API compatibility.
-}
diff --git a/crates/core/src/tracing/metrics.rs b/crates/core/src/tracing/metrics.rs
deleted file mode 100644
index 3a1460ef..00000000
--- a/crates/core/src/tracing/metrics.rs
+++ /dev/null
@@ -1,466 +0,0 @@
-//! Simple metrics collection for WASM and native environments
-//!
-//! This module provides basic metrics collection that works in both WASM
-//! and native environments by using atomic operations and tracing events.
-
-use std::collections::HashMap;
-use std::sync::atomic::{AtomicI64, AtomicU64, Ordering};
-use std::sync::{Arc, OnceLock, RwLock};
-use std::time::{Duration, Instant};
-
-/// A counter metric that can only increase
-#[derive(Clone)]
-pub struct Counter {
-    name: String,
-    value: Arc<AtomicU64>,
-}
-
-impl Counter {
-    /// Create a new counter
-    pub fn new(name: impl Into<String>) -> Self {
-        Self {
-            name: name.into(),
-            value: Arc::new(AtomicU64::new(0)),
-        }
-    }
-
-    /// Increment the counter by 1
-    pub fn increment(&self) {
-        self.add(1);
-    }
-
-    /// Add a value to the counter
-    pub fn add(&self, value: u64) {
-        let old = self.value.fetch_add(value, Ordering::Relaxed);
-        debug!(
-            metric = "counter",
-            name = %self.name,
-            value = value,
-            total = old + value,
-            "Counter incremented"
-        );
-    }
-
-    /// Get the current value
-    pub fn get(&self) -> u64 {
-        self.value.load(Ordering::Relaxed)
-    }
-}
-
-/// A gauge metric that can increase or decrease
-#[derive(Clone)]
-pub struct Gauge {
-    name: String,
-    value: Arc<AtomicI64>,
-}
-
-impl Gauge {
-    /// Create a new gauge
-    pub fn new(name: impl Into<String>) -> Self {
-        Self {
-            name: name.into(),
-            value: Arc::new(AtomicI64::new(0)),
-        }
-    }
-
-    /// Set the gauge value
-    pub fn set(&self, value: i64) {
-        self.value.store(value, Ordering::Relaxed);
-        debug!(
-            metric = "gauge",
-            name = %self.name,
-            value = value,
-            "Gauge set"
-        );
-    }
-
-    /// Increment the gauge by 1
-    pub fn increment(&self) {
-        let value = self.value.fetch_add(1, Ordering::Relaxed) + 1;
-        debug!(
-            metric = "gauge",
-            name = %self.name,
-            value = value,
-            "Gauge incremented"
-        );
-    }
-
-    /// Decrement the gauge by 1
-    pub fn decrement(&self) {
-        let value = self.value.fetch_sub(1, Ordering::Relaxed) - 1;
-        debug!(
-            metric = "gauge",
-            name = %self.name,
-            value = value,
-            "Gauge decremented"
-        );
-    }
-
-    /// Get the current value
-    pub fn get(&self) -> i64 {
-        self.value.load(Ordering::Relaxed)
-    }
-}
-
-/// Statistics for a histogram
-#[derive(Debug, Clone)]
-pub struct HistogramStats {
-    pub count: u64,
-    pub sum: f64,
-    pub mean: f64,
-    pub min: f64,
-    pub max: f64,
-    pub p50: f64,
-    pub p90: f64,
-    pub p95: f64,
-    pub p99: f64,
-}
-
-/// A histogram metric for recording durations
-#[derive(Clone)]
-pub struct Histogram {
-    name: String,
-    observations: Arc<RwLock<Vec<f64>>>,
-}
-
-impl Histogram {
-    /// Create a new histogram
-    pub fn new(name: impl Into<String>) -> Self {
-        Self {
-            name: name.into(),
-            observations: Arc::new(RwLock::new(Vec::new())),
-        }
-    }
-
-    /// Record an observation
-    pub fn observe(&self, value: f64) {
-        if let Ok(mut observations) = self.observations.write() {
-            observations.push(value);
-            debug!(
-                metric = "histogram",
-                name = %self.name,
-                value = value,
-                "Histogram observation recorded"
-            );
-        }
-    }
-
-    /// Record a duration
-    pub fn observe_duration(&self, duration: Duration) {
-        self.observe(duration.as_secs_f64());
-    }
-
-    /// Get statistics for the histogram
-    pub fn stats(&self) -> Option<HistogramStats> {
-        let observations = self.observations.read().ok()?;
-        if observations.is_empty() {
-            return None;
-        }
-
-        let mut sorted = observations.clone();
-        sorted.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
-
-        let count = sorted.len() as u64;
-        let sum: f64 = sorted.iter().sum();
-        let mean = sum / count as f64;
-        let min = *sorted.first().unwrap();
-        let max = *sorted.last().unwrap();
-
-        let percentile = |p: f64| -> f64 {
-            let index = ((count as f64 - 1.0) * p / 100.0) as usize;
-            sorted[index]
-        };
-
-        Some(HistogramStats {
-            count,
-            sum,
-            mean,
-            min,
-            max,
-            p50: percentile(50.0),
-            p90: percentile(90.0),
-            p95: percentile(95.0),
-            p99: percentile(99.0),
-        })
-    }
-
-    /// Clear all observations
-    pub fn clear(&self) {
-        if let Ok(mut observations) = self.observations.write() {
-            observations.clear();
-        }
-    }
-}
-
-/// Global metrics registry
-pub struct Metrics {
-    counters: RwLock<HashMap<String, Counter>>,
-    gauges: RwLock<HashMap<String, Gauge>>,
-    histograms: RwLock<HashMap<String, Histogram>>,
-}
-
-impl Metrics {
-    /// Create a new metrics registry
-    pub fn new() -> Self {
-        Self {
-            counters: RwLock::new(HashMap::new()),
-            gauges: RwLock::new(HashMap::new()),
-            histograms: RwLock::new(HashMap::new()),
-        }
-    }
-
-    /// Get or create a counter
-    pub fn counter(&self, name: &str) -> Counter {
-        if let Ok(counters) = self.counters.read()
-            && let Some(counter) = counters.get(name)
-        {
-            return counter.clone();
-        }
-
-        let counter = Counter::new(name);
-        if let Ok(mut counters) = self.counters.write() {
-            counters.insert(name.to_string(), counter.clone());
-        }
-        counter
-    }
-
-    /// Get or create a gauge
-    pub fn gauge(&self, name: &str) -> Gauge {
-        if let Ok(gauges) = self.gauges.read()
-            && let Some(gauge) = gauges.get(name)
-        {
-            return gauge.clone();
-        }
-
-        let gauge = Gauge::new(name);
-        if let Ok(mut gauges) = self.gauges.write() {
-            gauges.insert(name.to_string(), gauge.clone());
-        }
-        gauge
-    }
-
-    /// Get or create a histogram
-    pub fn histogram(&self, name: &str) -> Histogram {
-        if let Ok(histograms) = self.histograms.read()
-            && let Some(histogram) = histograms.get(name)
-        {
-            return histogram.clone();
-        }
-
-        let histogram = Histogram::new(name);
-        if let Ok(mut histograms) = self.histograms.write() {
-            histograms.insert(name.to_string(), histogram.clone());
-        }
-        histogram
-    }
-
-    /// Log all metrics
-    pub fn log_all(&self) {
-        info!("Logging all metrics");
-
-        // Log counters
-        if let Ok(counters) = self.counters.read() {
-            for (name, counter) in counters.iter() {
-                info!(
-                    metric_type = "counter",
-                    metric_name = %name,
-                    value = counter.get(),
-                    "Metric value"
-                );
-            }
-        }
-
-        // Log gauges
-        if let Ok(gauges) = self.gauges.read() {
-            for (name, gauge) in gauges.iter() {
-                info!(
-                    metric_type = "gauge",
-                    metric_name = %name,
-                    value = gauge.get(),
-                    "Metric value"
-                );
-            }
-        }
-
-        // Log histograms
-        if let Ok(histograms) = self.histograms.read() {
-            for (name, histogram) in histograms.iter() {
-                if let Some(stats) = histogram.stats() {
-                    info!(
-                        metric_type = "histogram",
-                        metric_name = %name,
-                        count = stats.count,
-                        sum = stats.sum,
-                        mean = stats.mean,
-                        min = stats.min,
-                        max = stats.max,
-                        p50 = stats.p50,
-                        p90 = stats.p90,
-                        p95 = stats.p95,
-                        p99 = stats.p99,
-                        "Metric value"
-                    );
-                }
-            }
-        }
-    }
-
-    /// Get all counters
-    pub fn all_counters(&self) -> HashMap<String, u64> {
-        self.counters
-            .read()
-            .ok()
-            .map(|counters| counters.iter().map(|(k, v)| (k.clone(), v.get())).collect())
-            .unwrap_or_default()
-    }
-
-    /// Get all gauges
-    pub fn all_gauges(&self) -> HashMap<String, i64> {
-        self.gauges
-            .read()
-            .ok()
-            .map(|gauges| gauges.iter().map(|(k, v)| (k.clone(), v.get())).collect())
-            .unwrap_or_default()
-    }
-
-    /// Get all histogram stats
-    pub fn all_histograms(&self) -> HashMap<String, HistogramStats> {
-        self.histograms
-            .read()
-            .ok()
-            .map(|histograms| {
-                histograms
-                    .iter()
-                    .filter_map(|(k, v)| v.stats().map(|stats| (k.clone(), stats)))
-                    .collect()
-            })
-            .unwrap_or_default()
-    }
-}
-
-impl Default for Metrics {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-// Global metrics instance
-static GLOBAL_METRICS: OnceLock<Metrics> = OnceLock::new();
-
-/// Get the global metrics instance, initializing if needed
-fn global_metrics() -> &'static Metrics {
-    GLOBAL_METRICS.get_or_init(Metrics::new)
-}
-
-/// Get or create a global counter
-pub fn counter(name: &str) -> Counter {
-    global_metrics().counter(name)
-}
-
-/// Get or create a global gauge
-pub fn gauge(name: &str) -> Gauge {
-    global_metrics().gauge(name)
-}
-
-/// Get or create a global histogram
-pub fn histogram(name: &str) -> Histogram {
-    global_metrics().histogram(name)
-}
-
-/// Log all global metrics
-pub fn log_all_metrics() {
-    global_metrics().log_all();
-}
-
-/// Get the global metrics instance
-pub fn global() -> &'static Metrics {
-    global_metrics()
-}
-
-/// Timer guard for recording durations
-pub struct Timer {
-    histogram: Histogram,
-    start: Instant,
-}
-
-impl Timer {
-    /// Create a new timer
-    pub fn new(histogram: Histogram) -> Self {
-        Self {
-            histogram,
-            start: Instant::now(),
-        }
-    }
-}
-
-impl Drop for Timer {
-    fn drop(&mut self) {
-        self.histogram.observe_duration(self.start.elapsed());
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_counter() {
-        let counter = Counter::new("test_counter");
-        assert_eq!(counter.get(), 0);
-
-        counter.increment();
-        assert_eq!(counter.get(), 1);
-
-        counter.add(5);
-        assert_eq!(counter.get(), 6);
-    }
-
-    #[test]
-    fn test_gauge() {
-        let gauge = Gauge::new("test_gauge");
-        assert_eq!(gauge.get(), 0);
-
-        gauge.set(10);
-        assert_eq!(gauge.get(), 10);
-
-        gauge.increment();
-        assert_eq!(gauge.get(), 11);
-
-        gauge.decrement();
-        assert_eq!(gauge.get(), 10);
-    }
-
-    #[test]
-    fn test_histogram() {
-        let histogram = Histogram::new("test_histogram");
-
-        histogram.observe(1.0);
-        histogram.observe(2.0);
-        histogram.observe(3.0);
-        histogram.observe(4.0);
-        histogram.observe(5.0);
-
-        let stats = histogram.stats().unwrap();
-        assert_eq!(stats.count, 5);
-        assert_eq!(stats.sum, 15.0);
-        assert_eq!(stats.mean, 3.0);
-        assert_eq!(stats.min, 1.0);
-        assert_eq!(stats.max, 5.0);
-        assert_eq!(stats.p50, 3.0);
-    }
-
-    #[test]
-    fn test_global_metrics() {
-        let counter1 = counter("global_counter");
-        let counter2 = counter("global_counter");
-
-        counter1.increment();
-        assert_eq!(counter2.get(), 1); // Same instance
-
-        let gauge1 = gauge("global_gauge");
-        let gauge2 = gauge("global_gauge");
-
-        gauge1.set(42);
-        assert_eq!(gauge2.get(), 42); // Same instance
-    }
-}
diff --git a/crates/core/src/tracing/mod.rs b/crates/core/src/tracing/mod.rs
deleted file mode 100644
index 62488ddf..00000000
--- a/crates/core/src/tracing/mod.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//! Shared tracing functionality for Gate
-//!
-//! This module provides common tracing utilities that work across both
-//! WASM and native environments.
-
-pub mod correlation;
-pub mod metrics;
-pub mod trace_context;
-
-#[cfg(all(feature = "tracing-otlp", not(target_arch = "wasm32")))]
-pub mod config;
-#[cfg(all(feature = "tracing-otlp", not(target_arch = "wasm32")))]
-pub mod init;
-
-#[cfg(all(feature = "tracing-prometheus", not(target_arch = "wasm32")))]
-pub mod prometheus;
-
-// Re-export commonly used types
-pub use correlation::CorrelationId;
-pub use trace_context::{TraceContext, TraceContextError};
-
-pub mod prelude {
-    pub use crate::tracing::correlation::CorrelationId;
-    pub use crate::tracing::metrics::{
-        Counter, Gauge, Histogram, Timer, counter, gauge, histogram, log_all_metrics,
-    };
-    pub use crate::tracing::trace_context::{
-        TraceContext, TraceContextError, extract_trace_context, inject_trace_context,
-    };
-
-    // Re-export common tracing macros and types
-    pub use tracing::{Instrument, debug, error, info, instrument, trace, warn};
-
-    // Native-only exports
-    #[cfg(not(target_arch = "wasm32"))]
-    pub use crate::tracing::correlation::{
-        CorrelationScope, current_correlation_id, set_current_correlation_id,
-    };
-}
diff --git a/crates/core/src/tracing/prometheus.rs b/crates/core/src/tracing/prometheus.rs
deleted file mode 100644
index 3e9ce170..00000000
--- a/crates/core/src/tracing/prometheus.rs
+++ /dev/null
@@ -1,161 +0,0 @@
-//! Prometheus metrics export
-//!
-//! This module provides functions to export metrics in Prometheus text format.
-
-use std::fmt::Write;
-
-use crate::tracing::metrics::Metrics;
-
-/// Export metrics in Prometheus text format
-pub fn export_prometheus(metrics: &Metrics) -> String {
-    let mut output = String::new();
-
-    // Export counters
-    for (name, value) in metrics.all_counters() {
-        let _ = writeln!(&mut output, "# TYPE {name} counter\n{name} {value}");
-    }
-
-    // Export gauges
-    for (name, value) in metrics.all_gauges() {
-        let _ = writeln!(&mut output, "# TYPE {name} gauge\n{name} {value}");
-    }
-
-    // Export histograms
-    for (name, stats) in metrics.all_histograms() {
-        let _ = writeln!(&mut output, "# TYPE {name} histogram");
-        let _ = writeln!(&mut output, "{name}_count {}", stats.count);
-        let _ = writeln!(&mut output, "{name}_sum {}", stats.sum);
-
-        // Export bucket values (simplified - using percentiles as buckets)
-        let _ = writeln!(
-            &mut output,
-            "{name}_bucket{{le=\"{}\"}} {}",
-            stats.p50,
-            stats.count / 2
-        );
-        let _ = writeln!(
-            &mut output,
-            "{name}_bucket{{le=\"{}\"}} {}",
-            stats.p90,
-            (stats.count * 9) / 10
-        );
-        let _ = writeln!(
-            &mut output,
-            "{name}_bucket{{le=\"{}\"}} {}",
-            stats.p95,
-            (stats.count * 95) / 100
-        );
-        let _ = writeln!(
-            &mut output,
-            "{name}_bucket{{le=\"{}\"}} {}",
-            stats.p99,
-            (stats.count * 99) / 100
-        );
-        let _ = writeln!(&mut output, "{name}_bucket{{le=\"+Inf\"}} {}", stats.count);
-    }
-
-    output
-}
-
-/// Export global metrics in Prometheus format
-pub fn prometheus_format() -> String {
-    export_prometheus(crate::tracing::metrics::global())
-}
-
-/// Alias for export_prometheus
-pub fn to_prometheus_format(metrics: &Metrics) -> String {
-    export_prometheus(metrics)
-}
-
-/// Format a Push Gateway URL
-pub fn format_push_gateway_url(base_url: &str, job: &str, instance: Option<&str>) -> String {
-    let mut url = format!("{}/metrics/job/{}", base_url.trim_end_matches('/'), job);
-    if let Some(inst) = instance {
-        url.push_str(&format!("/instance/{inst}"));
-    }
-    url
-}
-
-/// Create a JSON snapshot of metrics for logging
-pub fn create_metrics_snapshot(metrics: &Metrics) -> serde_json::Value {
-    serde_json::json!({
-        "counters": metrics.all_counters(),
-        "gauges": metrics.all_gauges(),
-        "histograms": metrics.all_histograms().into_iter().map(|(k, v)| {
-            (k, serde_json::json!({
-                "count": v.count,
-                "sum": v.sum,
-                "mean": v.mean,
-                "min": v.min,
-                "max": v.max,
-                "p50": v.p50,
-                "p90": v.p90,
-                "p95": v.p95,
-                "p99": v.p99,
-            }))
-        }).collect::<serde_json::Map<_, _>>(),
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::tracing::metrics::Metrics;
-
-    #[test]
-    fn test_export_prometheus() {
-        let metrics = Metrics::new();
-
-        // Add some test metrics
-        let counter = metrics.counter("test_counter");
-        counter.add(42);
-
-        let gauge = metrics.gauge("test_gauge");
-        gauge.set(100);
-
-        let histogram = metrics.histogram("test_histogram");
-        histogram.observe(1.0);
-        histogram.observe(2.0);
-        histogram.observe(3.0);
-
-        let output = export_prometheus(&metrics);
-
-        // Check counter
-        assert!(output.contains("# TYPE test_counter counter"));
-        assert!(output.contains("test_counter 42"));
-
-        // Check gauge
-        assert!(output.contains("# TYPE test_gauge gauge"));
-        assert!(output.contains("test_gauge 100"));
-
-        // Check histogram
-        assert!(output.contains("# TYPE test_histogram histogram"));
-        assert!(output.contains("test_histogram_count 3"));
-        assert!(output.contains("test_histogram_sum 6"));
-    }
-
-    #[test]
-    fn test_format_push_gateway_url() {
-        assert_eq!(
-            format_push_gateway_url("http://localhost:9091", "my_job", None),
-            "http://localhost:9091/metrics/job/my_job"
-        );
-
-        assert_eq!(
-            format_push_gateway_url("http://localhost:9091/", "my_job", Some("instance1")),
-            "http://localhost:9091/metrics/job/my_job/instance/instance1"
-        );
-    }
-
-    #[test]
-    fn test_create_metrics_snapshot() {
-        let metrics = Metrics::new();
-        metrics.counter("requests").add(10);
-        metrics.gauge("connections").set(5);
-
-        let snapshot = create_metrics_snapshot(&metrics);
-
-        assert_eq!(snapshot["counters"]["requests"], 10);
-        assert_eq!(snapshot["gauges"]["connections"], 5);
-    }
-}
diff --git a/crates/core/src/tracing/trace_context.rs b/crates/core/src/tracing/trace_context.rs
deleted file mode 100644
index 5447b6fd..00000000
--- a/crates/core/src/tracing/trace_context.rs
+++ /dev/null
@@ -1,366 +0,0 @@
-//! W3C Trace Context implementation
-//!
-//! This module implements the W3C Trace Context specification for distributed tracing.
-//! See: https://www.w3.org/TR/trace-context/
-
-#[cfg(not(target_arch = "wasm32"))]
-use rand::Rng;
-#[cfg(not(target_arch = "wasm32"))]
-use std::time::{SystemTime, UNIX_EPOCH};
-use std::{
-    collections::hash_map::DefaultHasher,
-    fmt,
-    hash::{Hash, Hasher},
-    str::FromStr,
-};
-
-use http::{HeaderMap, HeaderName, HeaderValue};
-use thiserror::Error;
-
-/// W3C Trace Context header names
-pub const TRACEPARENT_HEADER: &str = "traceparent";
-pub const TRACESTATE_HEADER: &str = "tracestate";
-
-/// Errors that can occur when parsing trace context
-#[derive(Error, Debug)]
-pub enum TraceContextError {
-    #[error("Invalid traceparent format")]
-    InvalidFormat,
-    #[error("Invalid version: {0}")]
-    InvalidVersion(String),
-    #[error("Invalid trace ID")]
-    InvalidTraceId,
-    #[error("Invalid span ID")]
-    InvalidSpanId,
-    #[error("Invalid flags")]
-    InvalidFlags,
-    #[error("Invalid header value: {0}")]
-    InvalidHeaderValue(String),
-}
-
-/// W3C Trace Context
-///
-/// Represents the traceparent header as defined in the W3C Trace Context specification.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct TraceContext {
-    version: u8,
-    trace_id: [u8; 16],
-    span_id: [u8; 8],
-    flags: u8,
-}
-
-impl TraceContext {
-    /// Create a new trace context with random IDs
-    pub fn new() -> Self {
-        let mut trace_id = [0u8; 16];
-        let mut span_id = [0u8; 8];
-
-        // Use getrandom for WASM compatibility
-        #[cfg(target_arch = "wasm32")]
-        {
-            getrandom::fill(&mut trace_id).expect("Failed to generate random trace ID");
-            getrandom::fill(&mut span_id).expect("Failed to generate random span ID");
-        }
-
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            let mut rng = rand::thread_rng();
-            rng.fill(&mut trace_id);
-            rng.fill(&mut span_id);
-        }
-
-        Self {
-            version: 0,
-            trace_id,
-            span_id,
-            flags: 1, // Sampled by default
-        }
-    }
-
-    /// Create a trace context from a legacy correlation ID
-    pub fn from_legacy_id(id: &str) -> Self {
-        // Generate deterministic trace and span IDs from the legacy ID
-        let mut hasher = DefaultHasher::new();
-        id.hash(&mut hasher);
-        let hash1 = hasher.finish();
-
-        hasher = DefaultHasher::new();
-        id.hash(&mut hasher);
-        "trace".hash(&mut hasher);
-        let hash2 = hasher.finish();
-
-        let mut trace_id = [0u8; 16];
-        trace_id[..8].copy_from_slice(&hash1.to_be_bytes());
-        trace_id[8..].copy_from_slice(&hash2.to_be_bytes());
-
-        let mut span_id = [0u8; 8];
-        span_id.copy_from_slice(&hash1.to_le_bytes());
-
-        Self {
-            version: 0,
-            trace_id,
-            span_id,
-            flags: 1, // Sampled by default
-        }
-    }
-
-    /// Get the trace ID
-    pub fn trace_id(&self) -> &[u8; 16] {
-        &self.trace_id
-    }
-
-    /// Get the span ID
-    pub fn span_id(&self) -> &[u8; 8] {
-        &self.span_id
-    }
-
-    /// Check if the trace is sampled
-    pub fn is_sampled(&self) -> bool {
-        self.flags & 0x01 != 0
-    }
-
-    /// Set the sampled flag
-    pub fn set_sampled(&mut self, sampled: bool) {
-        if sampled {
-            self.flags |= 0x01;
-        } else {
-            self.flags &= !0x01;
-        }
-    }
-
-    /// Create a child context with a new span ID
-    pub fn child(&self) -> Self {
-        let mut child = self.clone();
-
-        // Generate new span ID
-        #[cfg(target_arch = "wasm32")]
-        {
-            getrandom::fill(&mut child.span_id).expect("Failed to generate random span ID");
-        }
-
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            let now = SystemTime::now()
-                .duration_since(UNIX_EPOCH)
-                .unwrap()
-                .as_nanos();
-
-            let mut hasher = DefaultHasher::new();
-            now.hash(&mut hasher);
-            self.span_id.hash(&mut hasher);
-            let hash = hasher.finish();
-
-            child.span_id.copy_from_slice(&hash.to_be_bytes());
-        }
-
-        child
-    }
-}
-
-impl Default for TraceContext {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl fmt::Display for TraceContext {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "{:02x}-{}-{}-{:02x}",
-            self.version,
-            hex::encode(self.trace_id),
-            hex::encode(self.span_id),
-            self.flags
-        )
-    }
-}
-
-impl FromStr for TraceContext {
-    type Err = TraceContextError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        // Format: version-traceid-spanid-flags
-        let parts: Vec<&str> = s.split('-').collect();
-        if parts.len() != 4 {
-            return Err(TraceContextError::InvalidFormat);
-        }
-
-        // Parse version
-        let version = u8::from_str_radix(parts[0], 16)
-            .map_err(|_| TraceContextError::InvalidVersion(parts[0].to_string()))?;
-
-        // We only support version 00
-        if version != 0 {
-            return Err(TraceContextError::InvalidVersion(format!("{version:02x}")));
-        }
-
-        // Parse trace ID (32 hex chars = 16 bytes)
-        if parts[1].len() != 32 {
-            return Err(TraceContextError::InvalidTraceId);
-        }
-        let trace_id_vec = hex::decode(parts[1]).map_err(|_| TraceContextError::InvalidTraceId)?;
-        let mut trace_id = [0u8; 16];
-        trace_id.copy_from_slice(&trace_id_vec);
-
-        // Validate trace ID is not all zeros
-        if trace_id.iter().all(|&b| b == 0) {
-            return Err(TraceContextError::InvalidTraceId);
-        }
-
-        // Parse span ID (16 hex chars = 8 bytes)
-        if parts[2].len() != 16 {
-            return Err(TraceContextError::InvalidSpanId);
-        }
-        let span_id_vec = hex::decode(parts[2]).map_err(|_| TraceContextError::InvalidSpanId)?;
-        let mut span_id = [0u8; 8];
-        span_id.copy_from_slice(&span_id_vec);
-
-        // Validate span ID is not all zeros
-        if span_id.iter().all(|&b| b == 0) {
-            return Err(TraceContextError::InvalidSpanId);
-        }
-
-        // Parse flags
-        let flags =
-            u8::from_str_radix(parts[3], 16).map_err(|_| TraceContextError::InvalidFlags)?;
-
-        Ok(Self {
-            version,
-            trace_id,
-            span_id,
-            flags,
-        })
-    }
-}
-
-/// Extract trace context from HTTP headers
-pub fn extract_trace_context(headers: &HeaderMap) -> Option<TraceContext> {
-    headers
-        .get(TRACEPARENT_HEADER)
-        .and_then(|v| v.to_str().ok())
-        .and_then(|s| TraceContext::from_str(s).ok())
-}
-
-/// Inject trace context into HTTP headers
-pub fn inject_trace_context(
-    ctx: &TraceContext,
-    headers: &mut HeaderMap,
-) -> Result<(), TraceContextError> {
-    let traceparent = ctx.to_string();
-    let header_value = HeaderValue::from_str(&traceparent)
-        .map_err(|_| TraceContextError::InvalidHeaderValue(traceparent))?;
-
-    headers.insert(HeaderName::from_static(TRACEPARENT_HEADER), header_value);
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_new_trace_context() {
-        let ctx1 = TraceContext::new();
-        let ctx2 = TraceContext::new();
-
-        // Should have different IDs
-        assert_ne!(ctx1.trace_id, ctx2.trace_id);
-        assert_ne!(ctx1.span_id, ctx2.span_id);
-
-        // Should be sampled by default
-        assert!(ctx1.is_sampled());
-        assert!(ctx2.is_sampled());
-    }
-
-    #[test]
-    fn test_parse_traceparent() {
-        let traceparent = "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01";
-        let ctx = TraceContext::from_str(traceparent).unwrap();
-
-        assert_eq!(ctx.version, 0);
-        assert_eq!(
-            hex::encode(ctx.trace_id),
-            "4bf92f3577b34da6a3ce929d0e0e4736"
-        );
-        assert_eq!(hex::encode(ctx.span_id), "00f067aa0ba902b7");
-        assert_eq!(ctx.flags, 1);
-        assert!(ctx.is_sampled());
-
-        // Should round-trip
-        assert_eq!(ctx.to_string(), traceparent);
-    }
-
-    #[test]
-    fn test_invalid_traceparent() {
-        // Wrong number of parts
-        assert!(TraceContext::from_str("00-invalid").is_err());
-
-        // Invalid version
-        assert!(
-            TraceContext::from_str("ff-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01")
-                .is_err()
-        );
-
-        // Invalid trace ID (wrong length)
-        assert!(TraceContext::from_str("00-4bf92f3577b34da6-00f067aa0ba902b7-01").is_err());
-
-        // Invalid trace ID (all zeros)
-        assert!(
-            TraceContext::from_str("00-00000000000000000000000000000000-00f067aa0ba902b7-01")
-                .is_err()
-        );
-
-        // Invalid span ID (wrong length)
-        assert!(TraceContext::from_str("00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa-01").is_err());
-
-        // Invalid span ID (all zeros)
-        assert!(
-            TraceContext::from_str("00-4bf92f3577b34da6a3ce929d0e0e4736-0000000000000000-01")
-                .is_err()
-        );
-    }
-
-    #[test]
-    fn test_child_context() {
-        let parent = TraceContext::new();
-        let child = parent.child();
-
-        // Should have same trace ID
-        assert_eq!(parent.trace_id, child.trace_id);
-
-        // Should have different span ID
-        assert_ne!(parent.span_id, child.span_id);
-
-        // Should inherit flags
-        assert_eq!(parent.flags, child.flags);
-    }
-
-    #[test]
-    fn test_from_legacy_id() {
-        let legacy = "my-correlation-id";
-        let ctx1 = TraceContext::from_legacy_id(legacy);
-        let ctx2 = TraceContext::from_legacy_id(legacy);
-
-        // Should be deterministic
-        assert_eq!(ctx1.trace_id, ctx2.trace_id);
-        assert_eq!(ctx1.span_id, ctx2.span_id);
-
-        // Should be sampled
-        assert!(ctx1.is_sampled());
-    }
-
-    #[test]
-    fn test_extract_inject_headers() {
-        let ctx = TraceContext::new();
-        let mut headers = HeaderMap::new();
-
-        // Inject
-        inject_trace_context(&ctx, &mut headers).unwrap();
-        assert!(headers.contains_key(TRACEPARENT_HEADER));
-
-        // Extract
-        let extracted = extract_trace_context(&headers).unwrap();
-        assert_eq!(ctx, extracted);
-    }
-}
diff --git a/crates/core/src/types.rs b/crates/core/src/types.rs
deleted file mode 100644
index dadcfa2a..00000000
--- a/crates/core/src/types.rs
+++ /dev/null
@@ -1,159 +0,0 @@
-use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
-use serde_json::Value as JsonValue;
-use std::collections::HashMap;
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct User {
-    pub id: String,
-    pub name: Option<String>,
-    pub created_at: DateTime<Utc>,
-    pub updated_at: DateTime<Utc>,
-    pub disabled_at: Option<DateTime<Utc>>,
-    pub metadata: HashMap<String, String>,
-}
-
-impl User {
-    /// Check if the user is enabled (disabled_at is None)
-    pub fn is_enabled(&self) -> bool {
-        self.disabled_at.is_none()
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Organization {
-    pub id: String,
-    pub name: String,
-    pub created_at: DateTime<Utc>,
-    pub settings: HashMap<String, String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ApiKey {
-    pub key_hash: String,
-    pub name: String,
-    pub org_id: String,
-    pub config: Option<JsonValue>,
-    pub created_at: DateTime<Utc>,
-    pub last_used_at: Option<DateTime<Utc>>,
-}
-
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "UPPERCASE")]
-pub enum ProviderType {
-    Unknown,
-    OpenAI,
-    Anthropic,
-    Google,
-    Local,
-    Custom,
-}
-
-impl Default for ProviderType {
-    fn default() -> Self {
-        Self::Unknown
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Provider {
-    pub id: String,
-    pub name: String,
-    #[serde(rename = "type")]
-    pub provider_type: ProviderType,
-    pub config: Option<JsonValue>,
-    pub enabled: bool,
-    pub priority: u32,
-}
-
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "UPPERCASE")]
-pub enum ModelType {
-    Unknown,
-    Chat,
-    Completion,
-    Embedding,
-    Image,
-    Audio,
-}
-
-impl Default for ModelType {
-    fn default() -> Self {
-        Self::Unknown
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Model {
-    pub id: String,
-    pub provider_id: String,
-    pub name: String,
-    #[serde(rename = "type")]
-    pub model_type: ModelType,
-    pub capabilities: HashMap<String, String>,
-    pub pricing_id: Option<String>,
-    pub pricing_config: Option<JsonValue>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct UsageRecord {
-    pub id: String,
-    pub org_id: String,
-    pub user_id: String,
-    pub api_key_hash: String,
-    pub request_id: String,
-    pub provider_id: String,
-    pub model_id: String,
-    pub input_tokens: u64,
-    pub output_tokens: u64,
-    pub total_tokens: u64,
-    pub cost: f64,
-    pub timestamp: DateTime<Utc>,
-    pub metadata: HashMap<String, String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TimeRange {
-    pub start: DateTime<Utc>,
-    pub end: DateTime<Utc>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Error {
-    pub code: String,
-    pub message: String,
-    pub details: HashMap<String, String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct HookAction {
-    pub action_type: String,
-    pub payload: Option<JsonValue>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct HookResponse {
-    pub actions: Vec<HookAction>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RequestHookContext {
-    pub request_id: String,
-    pub user: Option<User>,
-    pub organization: Option<Organization>,
-    pub api_key: Option<ApiKey>,
-    pub request: JsonValue,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ResponseHookContext {
-    pub request_id: String,
-    pub user: Option<User>,
-    pub organization: Option<Organization>,
-    pub api_key: Option<ApiKey>,
-    pub request: JsonValue,
-    pub response: JsonValue,
-    pub usage: Option<UsageRecord>,
-}
-
-// Legacy chat/messages response types removed in favor of protocol-agnostic streaming APIs in router
diff --git a/crates/daemon/Cargo.toml b/crates/daemon/Cargo.toml
deleted file mode 100644
index eb049099..00000000
--- a/crates/daemon/Cargo.toml
+++ /dev/null
@@ -1,65 +0,0 @@
-[package]
-name = "gate-daemon"
-version.workspace = true
-edition.workspace = true
-authors.workspace = true
-license.workspace = true
-repository.workspace = true
-keywords.workspace = true
-categories.workspace = true
-
-[features]
-default = []
-otlp = ["gate-core/tracing-otlp"]
-
-[lib]
-name = "gate_daemon"
-path = "src/lib.rs"
-
-[[bin]]
-name = "gate"
-path = "src/main.rs"
-
-[dependencies]
-anyhow.workspace = true
-async-trait.workspace = true
-axum = { workspace = true, features = ["tokio", "http1"] }
-base64.workspace = true
-
-# Configuration
-chrono.workspace = true
-clap.workspace = true
-config.workspace = true
-directories.workspace = true
-dotenvy = "0.15"
-gate-core = { workspace = true, features = ["tracing", "tracing-otlp", "tracing-prometheus"] }
-gate-http = { workspace = true, features = ["server"] }
-gate-p2p.workspace = true
-gate-tlsforward = { workspace = true, features = ["client"] }
-gate-sqlx.workspace = true
-hex = "0.4"
-hyper-util = { workspace = true, default-features = false }
-iroh.workspace = true
-rand = { workspace = true }
-rustls = { version = "0.23", default-features = false, features = ["ring"] }
-serde.workspace = true
-serde_json.workspace = true
-thiserror.workspace = true
-tokio = { workspace = true, features = ["full"] }
-tokio-rustls = "0.26"
-tower = { workspace = true }
-tower-http = { workspace = true, features = ["cors", "trace", "fs"] }
-tracing.workspace = true
-tracing-subscriber.workspace = true
-
-futures.workspace = true
-uuid.workspace = true
-webauthn-rs.workspace = true
-catgrad-llm = { git = "https://github.com/hellas-ai/catgrad"}
-
-[dev-dependencies]
-futures = "0.3"
-rcgen = "0.14"
-reqwest = { version = "0.12", features = ["json"] }
-serde_json = "1"
-tempfile = "3"
diff --git a/crates/daemon/README.md b/crates/daemon/README.md
deleted file mode 100644
index b1d4967b..00000000
--- a/crates/daemon/README.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# gate-daemon
-
-The main Gate server binary that runs locally or on servers. Combines HTTP API server, P2P networking, and relay integration into a unified daemon.
-
-## Responsibilities
-
-- **HTTP Server**: Hosts OpenAI/Anthropic-compatible APIs on port 31145
-- **P2P Integration**: Connects to other Gate nodes via Iroh
-- **Relay Client**: Registers with relay for public HTTPS access
-- **TLS Management**: Automated Let's Encrypt certificates with hot reload
-- **Configuration**: JSON config file and environment variable support
-- **State Management**: Coordinates between HTTP, P2P and local Inference layers
-
-## Binary
-
-```bash
-gate
-```
-
-## Data Directory
-
-Default locations:
-- Linux: `~/.local/share/gate/`
-- macOS: `~/Library/Application Support/com.hellas.gate/`
-- Windows: `%APPDATA%\hellas\gate\`
diff --git a/crates/daemon/src/bootstrap.rs b/crates/daemon/src/bootstrap.rs
deleted file mode 100644
index 3a5ed81d..00000000
--- a/crates/daemon/src/bootstrap.rs
+++ /dev/null
@@ -1,245 +0,0 @@
-use anyhow::Result;
-use gate_sqlx::SqliteWebAuthnBackend;
-use rand::{Rng, distributions::Alphanumeric};
-use std::sync::Arc;
-use tokio::sync::RwLock;
-
-/// Manages the bootstrap token for initial user enrollment
-#[derive(Clone)]
-pub struct BootstrapTokenManager {
-    inner: Arc<RwLock<BootstrapTokenState>>,
-    webauthn_backend: Arc<SqliteWebAuthnBackend>,
-}
-
-#[derive(Debug)]
-struct BootstrapTokenState {
-    token: Option<String>,
-    is_used: bool,
-}
-
-impl BootstrapTokenManager {
-    /// Creates a new bootstrap token manager
-    pub fn new(webauthn_backend: Arc<SqliteWebAuthnBackend>) -> Self {
-        Self {
-            inner: Arc::new(RwLock::new(BootstrapTokenState {
-                token: None,
-                is_used: false,
-            })),
-            webauthn_backend,
-        }
-    }
-
-    /// Generates a new bootstrap token if none exists and hasn't been used
-    pub async fn generate_token(&self) -> Result<String> {
-        let mut state = self.inner.write().await;
-
-        if state.is_used {
-            anyhow::bail!("Bootstrap token has already been used");
-        }
-
-        if let Some(ref token) = state.token {
-            return Ok(token.clone());
-        }
-
-        // Generate a 32-character random alphanumeric token
-        let token: String = rand::thread_rng()
-            .sample_iter(&Alphanumeric)
-            .take(32)
-            .map(char::from)
-            .collect();
-
-        state.token = Some(token.clone());
-        Ok(token)
-    }
-
-    /// Validates a bootstrap token
-    pub async fn validate_token(&self, token: &str) -> Result<bool> {
-        let state = self.inner.read().await;
-
-        if state.is_used {
-            return Ok(false);
-        }
-
-        match &state.token {
-            Some(stored_token) => Ok(stored_token == token),
-            None => Ok(false),
-        }
-    }
-
-    /// Marks the bootstrap token as used
-    pub async fn mark_as_used(&self) -> Result<()> {
-        let mut state = self.inner.write().await;
-
-        if state.token.is_none() {
-            anyhow::bail!("No bootstrap token has been generated");
-        }
-
-        state.is_used = true;
-        state.token = None; // Clear the token for security
-        Ok(())
-    }
-
-    /// Checks if the bootstrap process has been completed
-    pub async fn is_bootstrap_complete(&self) -> bool {
-        let state = self.inner.read().await;
-        state.is_used
-    }
-
-    /// Gets the current token if available and not used
-    pub async fn get_token(&self) -> Option<String> {
-        let state = self.inner.read().await;
-        if !state.is_used {
-            state.token.clone()
-        } else {
-            None
-        }
-    }
-
-    /// Checks if bootstrap is needed (no credentials exist)
-    pub async fn needs_bootstrap(&self) -> Result<bool> {
-        let credentials = self.webauthn_backend.list_all_credentials().await?;
-        Ok(credentials.is_empty())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use gate_sqlx::{SqliteStateBackend, SqliteWebAuthnBackend};
-
-    async fn create_test_manager() -> Arc<BootstrapTokenManager> {
-        let state_backend = Arc::new(
-            SqliteStateBackend::new(":memory:")
-                .await
-                .expect("Failed to create backend"),
-        );
-        let webauthn_backend = Arc::new(SqliteWebAuthnBackend::new(state_backend.pool().clone()));
-        Arc::new(BootstrapTokenManager::new(webauthn_backend))
-    }
-
-    #[tokio::test]
-    async fn test_bootstrap_token_generation() {
-        let manager = create_test_manager().await;
-
-        // First token generation should succeed
-        let token1 = manager
-            .generate_token()
-            .await
-            .expect("Failed to generate token");
-        assert!(!token1.is_empty());
-
-        // Second generation should return the same token
-        let token2 = manager
-            .generate_token()
-            .await
-            .expect("Failed to generate token");
-        assert_eq!(token1, token2);
-    }
-
-    #[tokio::test]
-    async fn test_bootstrap_token_validation() {
-        let manager = create_test_manager().await;
-
-        // Generate a token
-        let token = manager
-            .generate_token()
-            .await
-            .expect("Failed to generate token");
-
-        // Valid token should pass
-        let valid = manager
-            .validate_token(&token)
-            .await
-            .expect("Failed to validate token");
-        assert!(valid);
-
-        // Invalid token should fail
-        let invalid = manager
-            .validate_token("invalid-token")
-            .await
-            .expect("Failed to validate token");
-        assert!(!invalid);
-    }
-
-    #[tokio::test]
-    async fn test_bootstrap_token_single_use() {
-        let manager = create_test_manager().await;
-
-        // Generate and validate token
-        let token = manager
-            .generate_token()
-            .await
-            .expect("Failed to generate token");
-
-        let valid = manager
-            .validate_token(&token)
-            .await
-            .expect("Failed to validate token");
-        assert!(valid);
-
-        // Mark as used
-        manager
-            .mark_as_used()
-            .await
-            .expect("Failed to mark token as used");
-
-        // Token should no longer be valid
-        let valid_after = manager
-            .validate_token(&token)
-            .await
-            .expect("Failed to validate token");
-        assert!(!valid_after);
-
-        // Should not be able to generate new token after use
-        let result = manager.generate_token().await;
-        assert!(result.is_err());
-    }
-
-    #[tokio::test]
-    async fn test_bootstrap_status() {
-        let manager = create_test_manager().await;
-
-        // Initially should need bootstrap
-        let needs = manager
-            .needs_bootstrap()
-            .await
-            .expect("Failed to check bootstrap status");
-        assert!(needs);
-
-        // Should not be complete
-        let complete = manager.is_bootstrap_complete().await;
-        assert!(!complete);
-
-        // Generate token
-        let _token = manager
-            .generate_token()
-            .await
-            .expect("Failed to generate token");
-
-        // Still needs bootstrap (token generated but not used)
-        let needs = manager
-            .needs_bootstrap()
-            .await
-            .expect("Failed to check bootstrap status");
-        assert!(needs);
-
-        // Mark as used
-        manager
-            .mark_as_used()
-            .await
-            .expect("Failed to mark token as used");
-
-        // Should no longer need bootstrap
-        let needs = manager
-            .needs_bootstrap()
-            .await
-            .expect("Failed to check bootstrap status");
-        // This will still be true because we haven't created any credentials
-        // In real usage, a user would be created after token validation
-        assert!(needs);
-
-        // Should be complete
-        let complete = manager.is_bootstrap_complete().await;
-        assert!(complete);
-    }
-}
diff --git a/crates/daemon/src/config.rs b/crates/daemon/src/config.rs
deleted file mode 100644
index c74eeb1a..00000000
--- a/crates/daemon/src/config.rs
+++ /dev/null
@@ -1,451 +0,0 @@
-//! Server configuration
-
-use std::path::PathBuf;
-
-use config::{Config, ConfigError, Environment, File};
-use serde::{Deserialize, Serialize};
-use serde_json::json;
-
-fn default_host() -> String {
-    "localhost".to_string()
-}
-
-fn default_port() -> u16 {
-    31145
-}
-
-fn default_true() -> bool {
-    true
-}
-
-fn default_false() -> bool {
-    false
-}
-
-fn default_rp_id() -> String {
-    default_host()
-}
-
-fn default_rp_name() -> String {
-    "Gate Self-Hosted".to_string()
-}
-
-fn default_rp_origin() -> String {
-    format!("http://{}:{}", default_host(), default_port())
-}
-
-fn default_session_timeout() -> u64 {
-    86400 // 24 hours
-}
-
-fn default_timeout() -> u64 {
-    30 // 30 seconds
-}
-
-fn default_jwt_issuer() -> String {
-    "gate-daemon".to_string()
-}
-
-fn generate_random_secret() -> String {
-    use rand::Rng;
-    let mut rng = rand::thread_rng();
-    let secret: String = (0..32)
-        .map(|_| rng.sample(rand::distributions::Alphanumeric) as char)
-        .collect();
-    secret
-}
-
-/// Default JWT secret, read from environment variable or generated if not set
-fn default_jwt_secret() -> String {
-    std::env::var("JWT_SECRET").unwrap_or_else(|_| generate_random_secret())
-}
-
-fn default_jwt_expiration_hours() -> u64 {
-    24 // 24 hours
-}
-
-fn default_heartbeat_interval() -> u64 {
-    30 // 30 seconds
-}
-
-fn default_max_reconnect_attempts() -> u32 {
-    10
-}
-
-fn default_reconnect_backoff() -> u64 {
-    5 // 5 seconds
-}
-
-fn default_auto_renew_days() -> u32 {
-    30 // 30 days before expiry
-}
-
-fn default_tlsforward_max_connections() -> usize {
-    1000
-}
-
-fn default_local_inference() -> Option<LocalInferenceConfig> {
-    Some(LocalInferenceConfig {
-        enabled: true,
-        max_concurrent_inferences: 1,
-        default_temperature: 0.7,
-        default_max_tokens: 1024,
-        models: vec![],
-    })
-}
-
-fn default_tlsforward_addresses() -> Vec<String> {
-    vec![
-        "3dbefb2e3d56c7e32586d9a82167a8a5151f3e0f4b40b7c3d145b9060dde2f14@213.239.212.173:31145"
-            .to_string(),
-    ]
-}
-
-/// Server configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Settings {
-    /// Server settings
-    #[serde(default)]
-    pub server: ServerConfig,
-    /// Authentication settings
-    #[serde(default)]
-    pub auth: AuthConfig,
-    /// Provider configurations
-    #[serde(default)]
-    pub providers: Vec<ProviderConfig>,
-    /// Relay configuration
-    #[serde(default)]
-    pub tlsforward: TlsForwardConfig,
-    /// Let's Encrypt configuration
-    #[serde(default)]
-    pub letsencrypt: LetsEncryptConfig,
-    /// Local inference configuration
-    #[serde(default = "default_local_inference")]
-    pub local_inference: Option<LocalInferenceConfig>,
-}
-
-impl Default for Settings {
-    fn default() -> Self {
-        serde_json::from_value(json!({})).expect("Default settings should always be valid")
-    }
-}
-
-/// Server configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ServerConfig {
-    /// Host to bind to
-    #[serde(default = "default_host")]
-    pub host: String,
-    /// Port to bind to
-    #[serde(default = "default_port")]
-    pub port: u16,
-    /// CORS allowed origins
-    #[serde(default)]
-    pub cors_origins: Vec<String>,
-    /// Prometheus metrics endpoint port (if enabled)
-    #[serde(default)]
-    pub metrics_port: Option<u16>,
-    /// Allow localhost clients to bypass auth (effective only when host is loopback)
-    #[serde(default = "default_true")]
-    pub allow_local_bypass: bool,
-}
-
-impl Default for ServerConfig {
-    fn default() -> Self {
-        serde_json::from_value(json!({})).expect("Default settings should always be valid")
-    }
-}
-
-/// Authentication configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AuthConfig {
-    /// WebAuthn configuration
-    #[serde(default)]
-    pub webauthn: WebAuthnConfig,
-    /// JWT configuration
-    #[serde(default)]
-    pub jwt: JwtConfig,
-    /// Registration configuration
-    #[serde(default)]
-    pub registration: RegistrationConfig,
-    /// Provider API key passthrough (Anthropic/OpenAI) for inference routes
-    #[serde(default)]
-    pub provider_passthrough: ProviderPassthroughConfig,
-}
-
-impl Default for AuthConfig {
-    fn default() -> Self {
-        serde_json::from_value(json!({})).expect("Default settings should always be valid")
-    }
-}
-
-/// Provider passthrough configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ProviderPassthroughConfig {
-    /// Enable passthrough of provider API keys from clients
-    #[serde(default = "default_true")]
-    pub enabled: bool,
-    /// Restrict passthrough to loopback peers only
-    #[serde(default = "default_true")]
-    pub loopback_only: bool,
-    /// Allowed HTTP paths for passthrough (exact match)
-    #[serde(default = "default_passthrough_paths")]
-    pub allowed_paths: Vec<String>,
-}
-
-fn default_passthrough_paths() -> Vec<String> {
-    vec![
-        "/v1/messages".to_string(),         // Anthropic
-        "/v1/chat/completions".to_string(), // OpenAI Chat
-        "/v1/responses".to_string(),        // OpenAI Responses
-        "/v1/completions".to_string(),      // OpenAI Completions (legacy)
-    ]
-}
-
-impl Default for ProviderPassthroughConfig {
-    fn default() -> Self {
-        serde_json::from_value(json!({})).expect("Default settings should always be valid")
-    }
-}
-
-/// Provider type
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum ProviderType {
-    Anthropic,
-    OpenAI,
-    Custom,
-}
-
-impl std::fmt::Display for ProviderType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            ProviderType::Anthropic => write!(f, "Anthropic"),
-            ProviderType::OpenAI => write!(f, "OpenAI"),
-            ProviderType::Custom => write!(f, "Custom"),
-        }
-    }
-}
-
-/// Provider configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ProviderConfig {
-    /// Name identifier for this provider
-    pub name: String,
-    /// Provider type
-    pub provider: ProviderType,
-    /// Base URL for the upstream API
-    pub base_url: String,
-    /// API key for authentication (can be set via env var)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub api_key: Option<String>,
-    /// Request timeout in seconds
-    #[serde(default = "default_timeout")]
-    pub timeout_seconds: u64,
-    /// List of supported models (populated on startup)
-    #[serde(default, skip_serializing)]
-    pub models: Vec<String>,
-}
-
-impl Default for ProviderConfig {
-    fn default() -> Self {
-        serde_json::from_value(json!({})).expect("Default settings should always be valid")
-    }
-}
-
-/// WebAuthn configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct WebAuthnConfig {
-    /// Relying Party ID (usually domain name)
-    #[serde(default = "default_rp_id")]
-    pub rp_id: String,
-    /// Relying Party Name (display name)
-    #[serde(default = "default_rp_name")]
-    pub rp_name: String,
-    /// Relying Party Origin (full URL)
-    #[serde(default = "default_rp_origin")]
-    pub rp_origin: String,
-    /// Additional allowed origins
-    #[serde(default)]
-    pub allowed_origins: Vec<String>,
-    /// Allow relay origins automatically (*.hellas.ai domains)
-    #[serde(default = "default_true")]
-    pub allow_tlsforward_origins: bool,
-    /// Allow subdomains of configured origins
-    #[serde(default = "default_true")]
-    pub allow_subdomains: bool,
-    /// Require user verification
-    #[serde(default = "default_false")]
-    pub require_user_verification: bool,
-    /// Session timeout in seconds
-    #[serde(default = "default_session_timeout")]
-    pub session_timeout_seconds: u64,
-}
-
-impl Default for WebAuthnConfig {
-    fn default() -> Self {
-        serde_json::from_value(json!({})).expect("Default settings should always be valid")
-    }
-}
-
-/// JWT configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct JwtConfig {
-    /// JWT issuer
-    #[serde(default = "default_jwt_issuer")]
-    pub issuer: String,
-    /// JWT secret (read from JWT_SECRET env var or generate)
-    #[serde(default = "default_jwt_secret")]
-    pub secret: String,
-    /// Token expiration in hours
-    #[serde(default = "default_jwt_expiration_hours")]
-    pub expiration_hours: u64,
-}
-
-impl Default for JwtConfig {
-    fn default() -> Self {
-        serde_json::from_value(json!({})).expect("Default settings should always be valid")
-    }
-}
-
-/// Registration configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RegistrationConfig {
-    /// Allow open registration after bootstrap
-    #[serde(default = "default_false")]
-    pub allow_open_registration: bool,
-}
-
-impl Default for RegistrationConfig {
-    fn default() -> Self {
-        serde_json::from_value(json!({})).expect("Default settings should always be valid")
-    }
-}
-
-/// TLS forward configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TlsForwardConfig {
-    /// Enable TLS forward functionality
-    #[serde(default = "default_false")]
-    pub enabled: bool,
-    /// List of TLS forward server addresses (NodeAddr format)
-    #[serde(default = "default_tlsforward_addresses")]
-    pub tlsforward_addresses: Vec<String>,
-    /// Maximum concurrent TLS connections
-    #[serde(default = "default_tlsforward_max_connections")]
-    pub max_connections: usize,
-    /// Path to store the secret key for persistent node ID
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub secret_key_path: Option<String>,
-    /// Heartbeat interval in seconds
-    #[serde(default = "default_heartbeat_interval")]
-    pub heartbeat_interval: u64,
-    /// Auto-reconnect on disconnect
-    #[serde(default = "default_true")]
-    pub auto_reconnect: bool,
-    /// Maximum reconnection attempts
-    #[serde(default = "default_max_reconnect_attempts")]
-    pub max_reconnect_attempts: u32,
-    /// Reconnection backoff in seconds
-    #[serde(default = "default_reconnect_backoff")]
-    pub reconnect_backoff: u64,
-}
-
-impl Default for TlsForwardConfig {
-    fn default() -> Self {
-        serde_json::from_value(json!({})).expect("Default settings should always be valid")
-    }
-}
-
-/// Local inference configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct LocalInferenceConfig {
-    /// Whether local inference is enabled
-    #[serde(default = "default_true")]
-    pub enabled: bool,
-    /// Maximum concurrent inference requests
-    #[serde(default = "default_max_concurrent_inferences")]
-    pub max_concurrent_inferences: usize,
-    /// Default temperature for inference when not specified
-    #[serde(default = "default_temperature")]
-    pub default_temperature: f32,
-    /// Default max tokens for inference when not specified
-    #[serde(default = "default_max_tokens")]
-    pub default_max_tokens: u32,
-    /// List of available models for local inference
-    #[serde(default)]
-    pub models: Vec<String>,
-}
-
-impl Default for LocalInferenceConfig {
-    fn default() -> Self {
-        serde_json::from_value(json!({})).expect("Default settings should always be valid")
-    }
-}
-
-fn default_max_concurrent_inferences() -> usize {
-    4
-}
-
-fn default_temperature() -> f32 {
-    0.7
-}
-
-fn default_max_tokens() -> u32 {
-    2048
-}
-
-/// Let's Encrypt configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct LetsEncryptConfig {
-    /// Enable Let's Encrypt certificate management
-    #[serde(default = "default_false")]
-    pub enabled: bool,
-    /// Email address for ACME account
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub email: Option<String>,
-    /// Use staging environment for testing
-    #[serde(default = "default_false")]
-    pub staging: bool,
-    /// Domains to request certificates for
-    #[serde(default)]
-    pub domains: Vec<String>,
-    /// Auto-renew certificates before expiry (days)
-    #[serde(default = "default_auto_renew_days")]
-    pub auto_renew_days: u32,
-}
-
-impl Default for LetsEncryptConfig {
-    fn default() -> Self {
-        serde_json::from_value(json!({})).expect("Default settings should always be valid")
-    }
-}
-
-impl Settings {
-    /// Load settings from a specific config file
-    pub fn load_from_file(path: impl Into<PathBuf>) -> Result<Self, ConfigError> {
-        let mut builder = Config::builder();
-
-        // Start with defaults
-        builder = builder.add_source(Config::try_from(&Settings::default())?);
-
-        // Add the specific config file
-        builder = builder.add_source(File::from(path.into()).required(true));
-
-        // Add environment variables with GATE_ prefix (can override file settings)
-        builder = builder.add_source(
-            Environment::with_prefix("GATE")
-                .separator("__")
-                .try_parsing(true),
-        );
-
-        let config = builder.build()?;
-        config.try_deserialize()
-    }
-
-    pub async fn save_to_file(&self, path: impl Into<PathBuf>) -> Result<(), std::io::Error> {
-        let config_str = serde_json::to_string_pretty(self)?;
-        std::fs::write(path.into(), config_str)?;
-        Ok(())
-    }
-}
diff --git a/crates/daemon/src/context.rs b/crates/daemon/src/context.rs
deleted file mode 100644
index 87feed11..00000000
--- a/crates/daemon/src/context.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-use async_trait::async_trait;
-use gate_core::RequestContext;
-use std::collections::HashMap;
-use std::env;
-
-/// Native server implementation of RequestContext
-pub struct NativeRequestContext {
-    headers: HashMap<String, String>,
-    url: String,
-    method: String,
-    body: Option<Vec<u8>>,
-}
-
-impl NativeRequestContext {
-    pub fn new(
-        headers: HashMap<String, String>,
-        url: String,
-        method: String,
-        body: Option<Vec<u8>>,
-    ) -> Self {
-        Self {
-            headers,
-            url,
-            method,
-            body,
-        }
-    }
-
-    /// Create from an Axum request
-    pub async fn from_axum_request(
-        req: axum::extract::Request,
-    ) -> Result<Self, Box<dyn std::error::Error + Send + Sync>> {
-        let method = req.method().to_string();
-        let url = req.uri().to_string();
-
-        // Extract headers
-        let mut headers = HashMap::new();
-        for (name, value) in req.headers() {
-            if let Ok(value_str) = value.to_str() {
-                headers.insert(name.to_string(), value_str.to_string());
-            }
-        }
-
-        // Extract body
-        let body = axum::body::to_bytes(req.into_body(), usize::MAX)
-            .await
-            .map(|b| b.to_vec())
-            .ok();
-
-        Ok(Self {
-            headers,
-            url,
-            method,
-            body,
-        })
-    }
-}
-
-#[async_trait]
-impl RequestContext for NativeRequestContext {
-    async fn get_env_var(&self, key: &str) -> Option<String> {
-        env::var(key).ok()
-    }
-
-    async fn get_secret(&self, key: &str) -> Option<String> {
-        // In production, this might read from a secure vault
-        // For now, we'll use environment variables with a SECRET_ prefix
-        env::var(format!("SECRET_{key}")).ok()
-    }
-
-    fn get_headers(&self) -> &HashMap<String, String> {
-        &self.headers
-    }
-
-    fn get_url(&self) -> &str {
-        &self.url
-    }
-
-    fn get_method(&self) -> &str {
-        &self.method
-    }
-
-    async fn get_body(&self) -> Result<Vec<u8>, Box<dyn std::error::Error + Send + Sync>> {
-        self.body.clone().ok_or_else(|| "No body available".into())
-    }
-
-    fn get_client_ip(&self) -> Option<String> {
-        // Check common headers for client IP
-        self.headers
-            .get("x-forwarded-for")
-            .and_then(|v| v.split(',').next())
-            .map(|ip| ip.trim().to_string())
-            .or_else(|| self.headers.get("x-real-ip").cloned())
-            .or_else(|| self.headers.get("x-client-ip").cloned())
-    }
-}
diff --git a/crates/daemon/src/daemon/actor.rs b/crates/daemon/src/daemon/actor.rs
deleted file mode 100644
index 89a49f67..00000000
--- a/crates/daemon/src/daemon/actor.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-use crate::daemon::inner::DaemonInner;
-use crate::daemon::rpc::DaemonRequest;
-use tokio::sync::mpsc;
-
-pub struct DaemonActor {
-    inner: DaemonInner,
-    rx: mpsc::Receiver<DaemonRequest>,
-}
-
-impl DaemonActor {
-    pub fn new(inner: DaemonInner, rx: mpsc::Receiver<DaemonRequest>) -> Self {
-        Self { inner, rx }
-    }
-
-    pub async fn run(mut self) {
-        while let Some(req) = self.rx.recv().await {
-            match req {
-                DaemonRequest::GetStatus { reply } => {
-                    let _ = reply.send(self.inner.status().await);
-                }
-                DaemonRequest::UpdateConfig {
-                    identity,
-                    config,
-                    reply,
-                } => {
-                    let result = self.inner.update_config(&identity, *config).await;
-                    let _ = reply.send(result);
-                }
-                DaemonRequest::Restart { identity, reply } => {
-                    let result = self.inner.restart(&identity).await;
-                    let _ = reply.send(result);
-                }
-                DaemonRequest::Shutdown { identity, reply } => {
-                    let result = self.inner.shutdown(&identity).await;
-                    let should_break = result.is_ok();
-                    let _ = reply.send(result);
-                    if should_break {
-                        break;
-                    }
-                }
-                DaemonRequest::GetSettings { reply } => {
-                    let _ = reply.send(self.inner.get_settings().await);
-                }
-                DaemonRequest::GetBootstrapManager { reply } => {
-                    let _ = reply.send(self.inner.get_bootstrap_manager());
-                }
-                DaemonRequest::GetWebAuthnService { reply } => {
-                    let _ = reply.send(self.inner.get_webauthn_service());
-                }
-                DaemonRequest::GetPermissionManager { reply } => {
-                    let _ = reply.send(self.inner.get_permission_manager());
-                }
-                DaemonRequest::GetAuthService { reply } => {
-                    let _ = reply.send(self.inner.get_auth_service());
-                }
-                DaemonRequest::GetStateBackend { reply } => {
-                    let _ = reply.send(self.inner.get_state_backend());
-                }
-                DaemonRequest::GetUserCount { reply } => {
-                    let _ = reply.send(self.inner.get_user_count());
-                }
-                DaemonRequest::GetConfig { identity, reply } => {
-                    let result = self.inner.get_config(&identity).await;
-                    let _ = reply.send(result);
-                }
-            }
-        }
-    }
-}
diff --git a/crates/daemon/src/daemon/builder.rs b/crates/daemon/src/daemon/builder.rs
deleted file mode 100644
index e46a8d58..00000000
--- a/crates/daemon/src/daemon/builder.rs
+++ /dev/null
@@ -1,188 +0,0 @@
-use crate::bootstrap::BootstrapTokenManager;
-use crate::daemon::{Daemon, actor::DaemonActor, inner::DaemonInner};
-use crate::error::Result;
-use crate::services::{AuthService, WebAuthnService};
-use crate::{Settings, StateDir};
-use gate_http::{
-    middleware::WebAuthnConfig,
-    services::{JwtConfig, JwtService},
-};
-use gate_sqlx::{SqliteStateBackend, SqliteWebAuthnBackend};
-use std::sync::Arc;
-use tokio::sync::mpsc;
-
-#[derive(Default)]
-pub struct DaemonBuilder {
-    settings: Option<Settings>,
-    state_dir: Option<StateDir>,
-    database_url: Option<String>,
-    static_dir: Option<String>,
-}
-
-impl DaemonBuilder {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn with_settings(mut self, settings: Settings) -> Self {
-        self.settings = Some(settings);
-        self
-    }
-
-    pub fn with_state_dir(mut self, state_dir: StateDir) -> Self {
-        self.state_dir = Some(state_dir);
-        self
-    }
-
-    pub fn with_database_url(mut self, url: String) -> Self {
-        self.database_url = Some(url);
-        self
-    }
-
-    pub fn with_static_dir(mut self, dir: String) -> Self {
-        self.static_dir = Some(dir);
-        self
-    }
-
-    /// Build the JWT service
-    fn build_jwt_service(settings: &Settings) -> Arc<JwtService> {
-        let jwt_config = JwtConfig {
-            secret: settings.auth.jwt.secret.clone(),
-            expiration: chrono::Duration::hours(settings.auth.jwt.expiration_hours as i64),
-            issuer: settings.auth.jwt.issuer.clone(),
-        };
-        Arc::new(JwtService::new(jwt_config))
-    }
-
-    pub async fn build(self) -> Result<Daemon> {
-        // Get or create state directory
-        let state_dir = self
-            .state_dir
-            .ok_or(crate::error::DaemonError::ConfigError(
-                "State directory not set".to_string(),
-            ))?;
-
-        // Get or create settings
-        let settings = if let Some(settings) = self.settings {
-            settings
-        } else {
-            let config_path = state_dir.config_path();
-            if config_path.exists() {
-                info!("Loading configuration from: {}", config_path.display());
-                Settings::load_from_file(config_path)
-                    .map_err(|e| crate::error::DaemonError::ConfigError(e.to_string()))?
-            } else {
-                info!("No config file found, using default settings");
-                Settings::default()
-            }
-        };
-
-        // Get database URL
-        let database_url = self.database_url.unwrap_or_else(|| {
-            format!(
-                "sqlite://{}",
-                state_dir.data_dir().join("gate.db").display()
-            )
-        });
-
-        // Create database backend
-        let state_backend = Arc::new(
-            SqliteStateBackend::new(&database_url)
-                .await
-                .map_err(|e| crate::error::DaemonError::Database(e.to_string()))?,
-        );
-        let webauthn_backend = Arc::new(SqliteWebAuthnBackend::new(state_backend.pool().clone()));
-
-        // Check bootstrap and count users
-        let bootstrap_manager = Arc::new(BootstrapTokenManager::new(webauthn_backend.clone()));
-
-        // Count existing users
-        let credentials = webauthn_backend.list_all_credentials().await.map_err(|e| {
-            crate::error::DaemonError::Database(format!("Failed to list credentials: {e}"))
-        })?;
-        let user_count = credentials.len();
-
-        if bootstrap_manager
-            .needs_bootstrap()
-            .await
-            .map_err(|e| crate::error::DaemonError::ConfigError(e.to_string()))?
-        {
-            let token = bootstrap_manager
-                .generate_token()
-                .await
-                .map_err(|e| crate::error::DaemonError::ConfigError(e.to_string()))?;
-            info!("Generated bootstrap token: {}", token);
-        }
-
-        // Build services
-        let jwt_service = Self::build_jwt_service(&settings);
-
-        // Build auth and webauthn services
-        let (auth_service, webauthn_service) = {
-            // Create WebAuthn configuration and service
-            let webauthn_config = WebAuthnConfig {
-                rp_id: settings.auth.webauthn.rp_id.clone(),
-                rp_name: settings.auth.webauthn.rp_name.clone(),
-                rp_origin: settings.auth.webauthn.rp_origin.clone(),
-                allowed_origins: settings.auth.webauthn.allowed_origins.clone(),
-                allow_tlsforward_origins: settings.auth.webauthn.allow_tlsforward_origins,
-                allow_subdomains: settings.auth.webauthn.allow_subdomains,
-                require_user_verification: settings.auth.webauthn.require_user_verification,
-                session_timeout_seconds: settings.auth.webauthn.session_timeout_seconds,
-            };
-
-            debug!(
-                "Creating WebAuthn service with RP ID: '{}', RP Origin: '{}', Allow Relay: {}",
-                webauthn_config.rp_id,
-                webauthn_config.rp_origin,
-                webauthn_config.allow_tlsforward_origins
-            );
-
-            let webauthn_service = Arc::new(
-                WebAuthnService::new(webauthn_config.clone(), webauthn_backend.clone()).map_err(
-                    |e| {
-                        crate::error::DaemonError::ConfigError(format!(
-                            "Failed to create WebAuthn service: {e}",
-                        ))
-                    },
-                )?,
-            );
-
-            let auth_service = Arc::new(AuthService::new(
-                jwt_service.clone(),
-                state_backend.clone(),
-                webauthn_backend.clone(),
-            ));
-
-            (auth_service, Some(webauthn_service))
-        };
-
-        // TODO: Setup TLS forward service if enabled
-        let tlsforward_service = None;
-
-        // Create DaemonInner
-        let daemon_inner = DaemonInner::new(
-            settings,
-            state_backend,
-            auth_service,
-            jwt_service,
-            bootstrap_manager,
-            webauthn_service,
-            tlsforward_service,
-            user_count,
-        )
-        .await;
-
-        // Create channel for actor communication
-        let (tx, rx) = mpsc::channel(100);
-
-        // Spawn actor
-        let actor = DaemonActor::new(daemon_inner, rx);
-        tokio::spawn(async move {
-            actor.run().await;
-        });
-
-        // Return daemon handle with static_dir
-        Ok(Daemon::new(tx, self.static_dir))
-    }
-}
diff --git a/crates/daemon/src/daemon/inner.rs b/crates/daemon/src/daemon/inner.rs
deleted file mode 100644
index f638f25b..00000000
--- a/crates/daemon/src/daemon/inner.rs
+++ /dev/null
@@ -1,213 +0,0 @@
-use crate::bootstrap::BootstrapTokenManager;
-use crate::error::Result;
-use crate::permissions::{LocalIdentity, LocalPermissionManager};
-use crate::services::{AuthService, TlsForwardService, WebAuthnService};
-use crate::types::{DaemonStatus, TlsForwardStatus};
-use crate::{Settings, state_dir::StateDir};
-use gate_core::StateBackend;
-use gate_core::access::{
-    Action, ObjectId, ObjectIdentity, ObjectKind, Permissions, TargetNamespace,
-};
-use gate_http::services::JwtService;
-use std::sync::Arc;
-use tokio::sync::RwLock;
-
-pub struct DaemonInner {
-    settings: Arc<RwLock<Settings>>,
-    state_backend: Arc<dyn StateBackend>,
-    permission_manager: Arc<LocalPermissionManager>,
-    auth_service: Arc<AuthService>,
-    jwt_service: Arc<JwtService>,
-    bootstrap_manager: Arc<BootstrapTokenManager>,
-    webauthn_service: Option<Arc<WebAuthnService>>,
-    tlsforward_service: Option<Arc<TlsForwardService>>,
-    user_count: usize,
-}
-
-impl DaemonInner {
-    #[allow(clippy::too_many_arguments)]
-    pub async fn new(
-        settings: Settings,
-        state_backend: Arc<dyn StateBackend>,
-        auth_service: Arc<AuthService>,
-        jwt_service: Arc<JwtService>,
-        bootstrap_manager: Arc<BootstrapTokenManager>,
-        webauthn_service: Option<Arc<WebAuthnService>>,
-        tlsforward_service: Option<Arc<TlsForwardService>>,
-        user_count: usize,
-    ) -> Self {
-        let permission_manager = Arc::new(LocalPermissionManager::new(state_backend.clone()));
-
-        Self {
-            settings: Arc::new(RwLock::new(settings)),
-            state_backend,
-            permission_manager,
-            auth_service,
-            jwt_service,
-            bootstrap_manager,
-            webauthn_service,
-            tlsforward_service,
-            user_count,
-        }
-    }
-
-    pub async fn status(&self) -> DaemonStatus {
-        let settings = self.settings.read().await;
-        DaemonStatus {
-            running: true,
-            listen_address: format!("{}:{}", settings.server.host, settings.server.port),
-            provider_count: settings.providers.len(),
-            user_count: self.user_count,
-            tlsforward_enabled: self.tlsforward_service.is_some(),
-            tlsforward_status: self.get_tlsforward_status().await,
-            needs_bootstrap: self.user_count == 0,
-        }
-    }
-
-    pub async fn update_config(
-        &mut self,
-        identity: &LocalIdentity,
-        config: Settings,
-    ) -> Result<()> {
-        let config_object = ObjectIdentity {
-            namespace: TargetNamespace::System,
-            kind: ObjectKind::Config,
-            id: ObjectId::new("*"),
-        };
-
-        self.permission_manager
-            .check(identity, Action::Write, &config_object)
-            .await?;
-
-        *self.settings.write().await = config;
-
-        // Persist to default config path
-        if let Ok(state_dir) = StateDir::new().await {
-            let path = state_dir.config_path();
-            if let Err(e) = self.settings.read().await.save_to_file(&path).await {
-                tracing::warn!("Failed to save settings to {}: {}", path.display(), e);
-            } else {
-                tracing::info!("Saved settings to {}", path.display());
-            }
-        } else {
-            tracing::warn!("Failed to resolve state dir; settings not persisted to disk");
-        }
-
-        self.reload_services().await?;
-        Ok(())
-    }
-
-    pub async fn restart(&mut self, identity: &LocalIdentity) -> Result<()> {
-        let daemon_object = ObjectIdentity {
-            namespace: TargetNamespace::System,
-            kind: ObjectKind::System,
-            id: ObjectId::new("daemon"),
-        };
-
-        self.permission_manager
-            .check(identity, Action::Manage, &daemon_object)
-            .await?;
-
-        self.shutdown_internal().await?;
-        self.start_internal().await?;
-        Ok(())
-    }
-
-    pub async fn shutdown(&mut self, identity: &LocalIdentity) -> Result<()> {
-        let daemon_object = ObjectIdentity {
-            namespace: TargetNamespace::System,
-            kind: ObjectKind::System,
-            id: ObjectId::new("daemon"),
-        };
-
-        self.permission_manager
-            .check(identity, Action::Manage, &daemon_object)
-            .await?;
-
-        self.shutdown_internal().await
-    }
-
-    pub fn get_user_count(&self) -> usize {
-        self.user_count
-    }
-
-    pub fn get_auth_service(&self) -> Arc<AuthService> {
-        self.auth_service.clone()
-    }
-
-    pub fn get_state_backend(&self) -> Arc<dyn StateBackend> {
-        self.state_backend.clone()
-    }
-
-    pub fn get_bootstrap_manager(&self) -> Arc<BootstrapTokenManager> {
-        self.bootstrap_manager.clone()
-    }
-
-    pub fn get_webauthn_service(&self) -> Option<Arc<WebAuthnService>> {
-        self.webauthn_service.clone()
-    }
-
-    pub fn get_permission_manager(&self) -> Arc<LocalPermissionManager> {
-        self.permission_manager.clone()
-    }
-
-    pub fn get_jwt_service(&self) -> Arc<JwtService> {
-        self.jwt_service.clone()
-    }
-
-    pub async fn get_settings(&self) -> Settings {
-        self.settings.read().await.clone()
-    }
-
-    pub async fn get_config(&self, identity: &LocalIdentity) -> Result<Settings> {
-        // Check permission to read configuration
-        let config_object = ObjectIdentity {
-            namespace: TargetNamespace::System,
-            kind: ObjectKind::Config,
-            id: ObjectId::new("*"),
-        };
-
-        self.permission_manager
-            .check(identity, Action::Read, &config_object)
-            .await?;
-
-        // Get the current configuration
-        let current_config = self.settings.read().await.clone();
-        Ok(current_config)
-    }
-
-    async fn get_tlsforward_status(&self) -> TlsForwardStatus {
-        if let Some(service) = &self.tlsforward_service {
-            let state = service.subscribe().borrow().clone();
-            match state {
-                crate::services::TlsForwardState::Disconnected => TlsForwardStatus::Disconnected,
-                crate::services::TlsForwardState::Connecting => TlsForwardStatus::Connecting,
-                crate::services::TlsForwardState::Connected {
-                    assigned_domain, ..
-                } => TlsForwardStatus::Connected {
-                    domain: assigned_domain,
-                },
-                crate::services::TlsForwardState::Error(error) => TlsForwardStatus::Error(error),
-            }
-        } else {
-            TlsForwardStatus::Disabled
-        }
-    }
-
-    async fn reload_services(&mut self) -> Result<()> {
-        // TODO: Implement service reloading logic
-        Ok(())
-    }
-
-    async fn shutdown_internal(&mut self) -> Result<()> {
-        if let Some(service) = &self.tlsforward_service {
-            service.shutdown().await;
-        }
-        Ok(())
-    }
-
-    async fn start_internal(&mut self) -> Result<()> {
-        // TODO: Implement service startup logic
-        Ok(())
-    }
-}
diff --git a/crates/daemon/src/daemon/mod.rs b/crates/daemon/src/daemon/mod.rs
deleted file mode 100644
index ca4540be..00000000
--- a/crates/daemon/src/daemon/mod.rs
+++ /dev/null
@@ -1,244 +0,0 @@
-pub mod actor;
-pub mod builder;
-pub mod inner;
-pub mod rpc;
-pub mod server;
-
-pub use builder::DaemonBuilder;
-use gate_core::router::{SinkIndex, SinkRegistry};
-
-use self::rpc::DaemonRequest;
-use crate::Settings;
-use crate::bootstrap::BootstrapTokenManager;
-use crate::error::{DaemonError, Result};
-use crate::permissions::LocalContext;
-use crate::permissions::LocalIdentity;
-use crate::services::WebAuthnService;
-use crate::types::DaemonStatus;
-use gate_core::access::SubjectIdentity;
-use std::sync::Arc;
-use tokio::sync::mpsc;
-use tokio::sync::oneshot;
-
-#[derive(Clone)]
-pub struct Daemon {
-    tx: mpsc::Sender<DaemonRequest>,
-    identity: Option<LocalIdentity>,
-    static_dir: Option<String>,
-}
-
-impl Daemon {
-    pub fn new(tx: mpsc::Sender<DaemonRequest>, static_dir: Option<String>) -> Self {
-        Self {
-            tx,
-            identity: None,
-            static_dir,
-        }
-    }
-
-    pub fn builder() -> DaemonBuilder {
-        DaemonBuilder::new()
-    }
-
-    pub fn with_identity(mut self, identity: LocalIdentity) -> Self {
-        self.identity = Some(identity);
-        self
-    }
-
-    pub async fn with_http_identity(
-        self,
-        identity: &gate_http::services::HttpIdentity,
-    ) -> Result<Self> {
-        // Get state backend to do the conversion
-        let state_backend = self.get_state_backend().await?;
-        let local_ctx = LocalContext::from_http_identity(identity, state_backend.as_ref()).await;
-        let local_identity =
-            SubjectIdentity::new(identity.id.clone(), identity.source.clone(), local_ctx);
-        Ok(self.with_identity(local_identity))
-    }
-
-    pub fn system_identity(&self) -> Self {
-        let identity = SubjectIdentity::new(
-            "system".to_string(),
-            "system".to_string(), // source
-            LocalContext {
-                is_owner: true,
-                node_id: "local".to_string(),
-            },
-        );
-        self.clone().with_identity(identity)
-    }
-
-    pub async fn status(&self) -> Result<DaemonStatus> {
-        let (reply, rx) = oneshot::channel();
-        self.tx.send(DaemonRequest::GetStatus { reply }).await?;
-        Ok(rx.await?)
-    }
-
-    pub async fn update_config(&self, config: Settings) -> Result<()> {
-        let identity = self
-            .identity
-            .clone()
-            .ok_or_else(|| DaemonError::InvalidState("No identity set".into()))?;
-
-        let (reply, rx) = oneshot::channel();
-        self.tx
-            .send(DaemonRequest::UpdateConfig {
-                identity,
-                config: Box::new(config),
-                reply,
-            })
-            .await?;
-        rx.await?
-    }
-
-    pub async fn restart(&self) -> Result<()> {
-        let identity = self
-            .identity
-            .clone()
-            .ok_or_else(|| DaemonError::InvalidState("No identity set".into()))?;
-
-        let (reply, rx) = oneshot::channel();
-        self.tx
-            .send(DaemonRequest::Restart { identity, reply })
-            .await?;
-        rx.await?
-    }
-
-    pub async fn shutdown(&self) -> Result<()> {
-        let identity = self
-            .identity
-            .clone()
-            .ok_or_else(|| DaemonError::InvalidState("No identity set".into()))?;
-
-        let (reply, rx) = oneshot::channel();
-        self.tx
-            .send(DaemonRequest::Shutdown { identity, reply })
-            .await?;
-        rx.await?
-    }
-
-    pub async fn get_settings(&self) -> Result<Settings> {
-        let (reply, rx) = oneshot::channel();
-        self.tx.send(DaemonRequest::GetSettings { reply }).await?;
-        Ok(rx.await?)
-    }
-
-    pub async fn get_bootstrap_manager(&self) -> Result<Arc<BootstrapTokenManager>> {
-        let (reply, rx) = oneshot::channel();
-        self.tx
-            .send(DaemonRequest::GetBootstrapManager { reply })
-            .await?;
-        Ok(rx.await?)
-    }
-
-    pub async fn get_webauthn_service(&self) -> Result<Option<Arc<WebAuthnService>>> {
-        let (reply, rx) = oneshot::channel();
-        self.tx
-            .send(DaemonRequest::GetWebAuthnService { reply })
-            .await?;
-        Ok(rx.await?)
-    }
-
-    pub async fn get_permission_manager(
-        &self,
-    ) -> Result<Arc<crate::permissions::LocalPermissionManager>> {
-        let (reply, rx) = oneshot::channel();
-        self.tx
-            .send(DaemonRequest::GetPermissionManager { reply })
-            .await?;
-        Ok(rx.await?)
-    }
-
-    pub async fn bootstrap_url(&self) -> Result<Option<String>> {
-        let bootstrap_manager = self.get_bootstrap_manager().await?;
-        let token = bootstrap_manager.get_token().await;
-        let status = self.status().await?;
-        Ok(token.map(|t| {
-            let port = status.listen_address.split(':').nth(1).unwrap_or("31145");
-            format!("http://localhost:{port}/bootstrap/{t}")
-        }))
-    }
-
-    pub async fn server_address(&self) -> Result<String> {
-        let status = self.status().await?;
-        Ok(status.listen_address)
-    }
-
-    pub async fn user_count(&self) -> Result<usize> {
-        let (reply, rx) = oneshot::channel();
-        self.tx.send(DaemonRequest::GetUserCount { reply }).await?;
-        Ok(rx.await?)
-    }
-
-    pub async fn get_auth_service(&self) -> Result<Arc<crate::services::AuthService>> {
-        let (reply, rx) = oneshot::channel();
-        self.tx
-            .send(DaemonRequest::GetAuthService { reply })
-            .await?;
-        Ok(rx.await?)
-    }
-
-    pub async fn get_state_backend(&self) -> Result<Arc<dyn gate_core::StateBackend>> {
-        let (reply, rx) = oneshot::channel();
-        self.tx
-            .send(DaemonRequest::GetStateBackend { reply })
-            .await?;
-        Ok(rx.await?)
-    }
-
-    pub async fn get_config(&self) -> Result<Settings> {
-        let identity = self
-            .identity
-            .clone()
-            .ok_or_else(|| DaemonError::InvalidState("No identity set".into()))?;
-
-        let (reply, rx) = oneshot::channel();
-        self.tx
-            .send(DaemonRequest::GetConfig { identity, reply })
-            .await?;
-        rx.await?
-    }
-
-    /// Serve the daemon - uses ServerBuilder to reduce complexity
-    pub async fn serve(self) -> Result<()> {
-        // Get settings and create builder
-        let settings = self.get_settings().await?;
-        let builder = server::ServerBuilder::new(self.clone(), Arc::new(settings));
-
-        // Step 1: Bind listener early to fail fast
-        let listener = builder.bind_listener().await?;
-
-        // Step 2: Get core services
-        let state_backend = self.get_state_backend().await?;
-
-        // Step 3: Initialize state and router (router is missing state)
-        let state = builder.create_state().await?;
-        let mut app_state = gate_http::AppState::new(state_backend.clone(), state);
-        let router = builder.init_router();
-
-        // Step 4: Setup sink registry and register all sinks
-        let sink_registry = Arc::new(SinkRegistry::new());
-        builder.register_sinks(&sink_registry).await?;
-
-        // Step 5: Setup sink index
-        let sink_index = Arc::new(SinkIndex::new());
-        sink_index.refresh_from_registry(&sink_registry).await;
-
-        // Step 6: Build core router with strategies and middleware
-        let router_core = builder
-            .build_router_core(state_backend, sink_registry, sink_index)
-            .await;
-        app_state = app_state.with_router(router_core);
-
-        // Step 7: Build complete application with all middleware (still missing state)
-        let app_missing_state = builder.build_app(router, app_state.clone()).await;
-
-        // Step 8: Supply the actual state and serve the application
-        let app = app_missing_state.with_state(app_state);
-        axum::serve(listener, app).await.map_err(DaemonError::Io)?;
-
-        Ok(())
-    }
-}
-// axum 0.8: no ServiceExt needed
diff --git a/crates/daemon/src/daemon/rpc.rs b/crates/daemon/src/daemon/rpc.rs
deleted file mode 100644
index a542035c..00000000
--- a/crates/daemon/src/daemon/rpc.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-use crate::Settings;
-use crate::bootstrap::BootstrapTokenManager;
-use crate::error::Result;
-use crate::permissions::{LocalIdentity, LocalPermissionManager};
-use crate::services::{AuthService, WebAuthnService};
-use crate::types::DaemonStatus;
-use gate_core::StateBackend;
-use std::sync::Arc;
-use tokio::sync::oneshot;
-
-pub enum DaemonRequest {
-    GetStatus {
-        reply: oneshot::Sender<DaemonStatus>,
-    },
-    UpdateConfig {
-        identity: LocalIdentity,
-        config: Box<Settings>,
-        reply: oneshot::Sender<Result<()>>,
-    },
-    Restart {
-        identity: LocalIdentity,
-        reply: oneshot::Sender<Result<()>>,
-    },
-    Shutdown {
-        identity: LocalIdentity,
-        reply: oneshot::Sender<Result<()>>,
-    },
-    GetSettings {
-        reply: oneshot::Sender<Settings>,
-    },
-    GetBootstrapManager {
-        reply: oneshot::Sender<Arc<BootstrapTokenManager>>,
-    },
-    GetWebAuthnService {
-        reply: oneshot::Sender<Option<Arc<WebAuthnService>>>,
-    },
-    GetPermissionManager {
-        reply: oneshot::Sender<Arc<LocalPermissionManager>>,
-    },
-    GetAuthService {
-        reply: oneshot::Sender<Arc<AuthService>>,
-    },
-    GetStateBackend {
-        reply: oneshot::Sender<Arc<dyn StateBackend>>,
-    },
-    GetUserCount {
-        reply: oneshot::Sender<usize>,
-    },
-    GetConfig {
-        identity: LocalIdentity,
-        reply: oneshot::Sender<Result<Settings>>,
-    },
-}
diff --git a/crates/daemon/src/daemon/server.rs b/crates/daemon/src/daemon/server.rs
deleted file mode 100644
index deaee2ac..00000000
--- a/crates/daemon/src/daemon/server.rs
+++ /dev/null
@@ -1,325 +0,0 @@
-//! Server-related functionality extracted from daemon/mod.rs
-
-use crate::{
-    State,
-    config::{LocalInferenceConfig, ProviderConfig, ProviderType, Settings},
-    daemon::{Daemon, Result},
-    error::DaemonError,
-    services::{LocalInferenceService, key_capture::DaemonKeyRegistrar},
-    sinks::catgrad_sink::CatgradSink,
-};
-use axum::http::HeaderName;
-use gate_core::{
-    router::{
-        Sink,
-        index::SinkIndex,
-        middleware::KeyCaptureMiddleware,
-        registry::SinkRegistry,
-        routing::Router,
-        strategy::{CompositeStrategy, ProviderAffinityStrategy, SimpleStrategy},
-    },
-    state::StateBackend,
-};
-use gate_http::{
-    AppState,
-    sinks::{
-        anthropic::{self, AnthropicConfig},
-        openai::{self, OpenAIConfig},
-    },
-};
-use std::sync::Arc;
-use tower_http::services::{ServeDir, ServeFile};
-use tracing::{info, warn};
-
-pub struct ServerBuilder {
-    daemon: Daemon,
-    settings: Arc<Settings>,
-}
-
-impl ServerBuilder {
-    pub fn new(daemon: Daemon, settings: Arc<Settings>) -> Self {
-        Self { daemon, settings }
-    }
-
-    /// Build and bind TCP listener
-    pub async fn bind_listener(&self) -> Result<tokio::net::TcpListener> {
-        let addr = format!(
-            "{}:{}",
-            self.settings.server.host, self.settings.server.port
-        );
-        let listener = tokio::net::TcpListener::bind(&addr)
-            .await
-            .map_err(DaemonError::Io)?;
-        info!("Server will listen on http://{}", addr);
-        Ok(listener)
-    }
-
-    /// Initialize base router with authentication routes
-    ///
-    /// Returns a router that is missing `AppState<State>`.
-    /// The actual state value is supplied at the end before serving.
-    pub fn init_router(&self) -> axum::Router<AppState<State>> {
-        let router: axum::Router<AppState<State>> = axum::Router::new();
-        let router = crate::routes::auth::add_routes(router);
-        let router = crate::routes::config::add_routes(router);
-        crate::routes::admin::add_routes(router)
-    }
-
-    /// Create state for the application
-    pub async fn create_state(&self) -> Result<State> {
-        let auth_service = self.daemon.get_auth_service().await?;
-        let allow_local_bypass =
-            self.settings.server.allow_local_bypass && is_local_host(&self.settings.server.host);
-
-        Ok(State::new(
-            auth_service,
-            self.daemon.clone(),
-            allow_local_bypass,
-            self.settings.auth.provider_passthrough.clone(),
-        ))
-    }
-
-    /// Register all provider sinks
-    pub async fn register_sinks(&self, registry: &Arc<SinkRegistry>) -> Result<()> {
-        let mut has_anthropic = false;
-        let mut has_openai = false;
-
-        // Register configured provider sinks
-        for provider_config in &self.settings.providers {
-            let sink = match self.create_provider_sink(provider_config).await {
-                Ok(s) => s,
-                Err(e) => {
-                    warn!("Failed to create {} sink: {}", provider_config.provider, e);
-                    continue;
-                }
-            };
-
-            match provider_config.provider {
-                ProviderType::Anthropic => has_anthropic = true,
-                ProviderType::OpenAI => has_openai = true,
-                ProviderType::Custom => {}
-            }
-
-            let sink_id = format_provider_sink_id(&provider_config.provider, &provider_config.name);
-            registry.register(sink_id, sink).await;
-            info!("Registered provider sink: {}", provider_config.name);
-        }
-
-        // Register fallback sinks if needed
-        if !has_anthropic {
-            self.register_anthropic_fallback(registry).await;
-        }
-        if !has_openai {
-            self.register_openai_fallbacks(registry).await;
-        }
-
-        // Register local inference sink if configured
-        if let Some(ref inf_cfg) = self.settings.local_inference {
-            self.register_catgrad_sink(registry, inf_cfg).await;
-        }
-
-        Ok(())
-    }
-
-    /// Create a provider sink based on configuration
-    async fn create_provider_sink(&self, config: &ProviderConfig) -> Result<Arc<dyn Sink>> {
-        match config.provider {
-            ProviderType::Anthropic => {
-                let anthropic_config = AnthropicConfig {
-                    api_key: config.api_key.clone(),
-                    base_url: Some(config.base_url.clone()),
-                    timeout_seconds: Some(config.timeout_seconds),
-                    sink_id: Some(format!("provider://anthropic/{}", config.name)),
-                };
-                anthropic::create_sink(anthropic_config)
-                    .await
-                    .map(|sink| Arc::new(sink) as Arc<dyn Sink>)
-                    .map_err(|e| DaemonError::ServiceUnavailable(e.to_string()))
-            }
-            ProviderType::OpenAI => {
-                let openai_config = OpenAIConfig {
-                    api_key: config.api_key.clone(),
-                    base_url: Some(config.base_url.clone()),
-                    models: if config.models.is_empty() {
-                        None
-                    } else {
-                        Some(config.models.clone())
-                    },
-                    timeout_seconds: Some(config.timeout_seconds),
-                    sink_id: Some(format!("provider://openai/{}", config.name)),
-                };
-                openai::create_sink(openai_config)
-                    .map(|sink| Arc::new(sink) as Arc<dyn Sink>)
-                    .map_err(|e| DaemonError::ServiceUnavailable(e.to_string()))
-            }
-            ProviderType::Custom => Err(DaemonError::ConfigError(
-                "Custom provider type not yet implemented".to_string(),
-            )),
-        }
-    }
-
-    /// Register Anthropic fallback sink
-    async fn register_anthropic_fallback(&self, registry: &Arc<SinkRegistry>) {
-        match anthropic::create_fallback_sink().await {
-            Ok(sink) => {
-                registry
-                    .register("provider://anthropic/fallback".to_string(), Arc::new(sink))
-                    .await;
-                info!(
-                    "Registered fallback Anthropic sink (no API key; will capture on first success)"
-                );
-            }
-            Err(e) => warn!("Failed to create fallback Anthropic sink: {}", e),
-        }
-    }
-
-    /// Register OpenAI fallback sinks
-    async fn register_openai_fallbacks(&self, registry: &Arc<SinkRegistry>) {
-        // Standard OpenAI fallback
-        match openai::create_fallback_sink() {
-            Ok(sink) => {
-                registry
-                    .register("provider://openai/fallback".to_string(), Arc::new(sink))
-                    .await;
-                info!("Registered fallback OpenAI sink (no API key; will accept client keys)");
-            }
-            Err(e) => warn!("Failed to create fallback OpenAI sink: {}", e),
-        }
-
-        // Codex fallback for ChatGPT backend
-        match openai::create_codex_fallback_sink() {
-            Ok(sink) => {
-                registry
-                    .register("provider://openai/codex".to_string(), Arc::new(sink))
-                    .await;
-                info!("Registered fallback OpenAI Codex sink (OAuth tokens; /backend-api/codex)");
-            }
-            Err(e) => warn!("Failed to create fallback OpenAI Codex sink: {}", e),
-        }
-    }
-
-    /// Register Catgrad sink for local inference
-    async fn register_catgrad_sink(
-        &self,
-        registry: &Arc<SinkRegistry>,
-        config: &LocalInferenceConfig,
-    ) {
-        match LocalInferenceService::new(config.clone()) {
-            Ok(_) => {
-                let sink = Arc::new(CatgradSink::new("self://catgrad", config.models.clone()));
-                registry.register("self://catgrad".to_string(), sink).await;
-                info!("Registered Catgrad sink for local inference");
-            }
-            Err(e) => warn!("Failed to initialize LocalInferenceService: {}", e),
-        }
-    }
-
-    /// Build the core router with strategies and middleware
-    pub async fn build_router_core(
-        &self,
-        state_backend: Arc<dyn StateBackend>,
-        sink_registry: Arc<SinkRegistry>,
-        sink_index: Arc<SinkIndex>,
-    ) -> Arc<Router> {
-        let registrar = Arc::new(DaemonKeyRegistrar::new(
-            self.daemon.clone(),
-            sink_registry.clone(),
-            sink_index.clone(),
-        ));
-
-        let router = Router::builder()
-            .state_backend(state_backend)
-            .sink_registry(sink_registry)
-            .strategy(Box::new(CompositeStrategy::new(vec![
-                (Box::new(ProviderAffinityStrategy::new()), 1.0),
-                (Box::new(SimpleStrategy::new()), 0.1),
-            ])))
-            .middleware(Arc::new(KeyCaptureMiddleware::new(registrar)))
-            .sink_index(sink_index)
-            .build();
-
-        Arc::new(router)
-    }
-
-    /// Configure middleware layers
-    pub fn configure_middleware<S>(&self, app: axum::Router<S>) -> axum::Router<S>
-    where
-        S: Clone + Send + Sync + 'static,
-    {
-        app.layer(
-            tower_http::cors::CorsLayer::new()
-                .allow_origin(tower_http::cors::Any)
-                .allow_methods(tower_http::cors::Any)
-                .allow_headers(vec![
-                    axum::http::header::CONTENT_TYPE,
-                    axum::http::header::AUTHORIZATION,
-                    HeaderName::from_static("x-correlation-id"),
-                    HeaderName::from_static("x-api-key"),
-                    HeaderName::from_static("traceparent"),
-                    HeaderName::from_static("tracestate"),
-                ])
-                .expose_headers(vec![
-                    HeaderName::from_static("x-correlation-id"),
-                    HeaderName::from_static("traceparent"),
-                    HeaderName::from_static("tracestate"),
-                ]),
-        )
-        .layer(axum::middleware::from_fn(
-            gate_http::middleware::correlation_id_middleware,
-        ))
-    }
-
-    /// Add static file serving if configured
-    pub fn add_static_serving<S>(&self, app: axum::Router<S>) -> axum::Router<S>
-    where
-        S: Clone + Send + Sync + 'static,
-    {
-        if let Some(static_dir) = &self.daemon.static_dir {
-            if std::path::Path::new(static_dir).exists() {
-                info!("Serving static files from: {}", static_dir);
-                let index_path = format!("{static_dir}/index.html");
-                let serve_dir = ServeDir::new(static_dir).fallback(ServeFile::new(index_path));
-                return app.fallback_service(serve_dir);
-            } else {
-                warn!("Static directory not found: {}", static_dir);
-            }
-        }
-        app
-    }
-
-    /// Build the complete application
-    pub async fn build_app(
-        &self,
-        router: axum::Router<AppState<State>>,
-        app_state: AppState<State>,
-    ) -> axum::Router<AppState<State>> {
-        let app: axum::Router<AppState<State>> = router;
-
-        let app = app
-            // Merge common HTTP routes (health, inference, models, observability)
-            .merge(gate_http::routes::router::<State>())
-            // Apply auth middleware
-            .route_layer(axum::middleware::from_fn_with_state(
-                app_state.clone(),
-                gate_http::middleware::auth::auth_middleware::<State>,
-            ));
-
-        let app = self.configure_middleware(app);
-        let app = self.add_static_serving(app);
-        gate_http::middleware::with_request_tracing(app)
-    }
-}
-
-/// Helper function to check if host is localhost
-fn is_local_host(host: &str) -> bool {
-    matches!(host, "localhost" | "127.0.0.1" | "::1")
-}
-
-/// Format provider sink ID
-fn format_provider_sink_id(provider: &ProviderType, name: &str) -> String {
-    match provider {
-        ProviderType::Anthropic => format!("provider://anthropic/{name}"),
-        ProviderType::OpenAI => format!("provider://openai/{name}"),
-        ProviderType::Custom => format!("provider://{name}"),
-    }
-}
diff --git a/crates/daemon/src/error.rs b/crates/daemon/src/error.rs
deleted file mode 100644
index 1cf9b62e..00000000
--- a/crates/daemon/src/error.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-use gate_core::access::PermissionDenied;
-use thiserror::Error;
-use tokio::sync::mpsc;
-use tokio::sync::oneshot;
-
-#[derive(Debug, Error)]
-pub enum DaemonError {
-    #[error("Permission denied: {0}")]
-    PermissionDenied(#[from] PermissionDenied),
-
-    #[error("Configuration error: {0}")]
-    ConfigError(String),
-
-    #[error("Serde error: {0}")]
-    Serde(#[from] serde_json::Error),
-
-    #[error("Service unavailable: {0}")]
-    ServiceUnavailable(String),
-
-    #[error("Invalid state: {0}")]
-    InvalidState(String),
-
-    #[error("IO error: {0}")]
-    Io(#[from] std::io::Error),
-
-    #[error("Database error: {0}")]
-    Database(String),
-
-    #[error("TLS forward error: {0}")]
-    TlsForward(String),
-
-    #[error("Channel send error")]
-    ChannelSend,
-
-    #[error("Channel receive error")]
-    ChannelRecv(#[from] oneshot::error::RecvError),
-
-    #[error("Platform directories could not be determined")]
-    PlatformDirsNotFound,
-}
-
-impl<T> From<mpsc::error::SendError<T>> for DaemonError {
-    fn from(_: mpsc::error::SendError<T>) -> Self {
-        DaemonError::ChannelSend
-    }
-}
-
-pub type Result<T> = std::result::Result<T, DaemonError>;
diff --git a/crates/daemon/src/helpers/admin.rs b/crates/daemon/src/helpers/admin.rs
deleted file mode 100644
index 0e53bbfa..00000000
--- a/crates/daemon/src/helpers/admin.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-//! Admin route helper functions to reduce repetitive permission checking code
-
-use crate::permissions::LocalContext;
-use gate_core::access::{Action, ObjectIdentity, Permissions, SubjectIdentity};
-use gate_core::state::StateBackend;
-use gate_http::{error::HttpError, services::HttpIdentity};
-use std::sync::Arc;
-
-/// Helper struct to handle common admin permission checks
-pub struct AdminPermissionHelper {
-    pub permission_manager: Arc<crate::permissions::LocalPermissionManager>,
-    pub state_backend: Arc<dyn StateBackend>,
-    pub identity: HttpIdentity,
-    pub local_identity: SubjectIdentity<LocalContext>,
-}
-
-impl AdminPermissionHelper {
-    /// Create a new AdminPermissionHelper from app state and identity
-    pub async fn new(
-        daemon: &crate::daemon::Daemon,
-        identity: HttpIdentity,
-    ) -> Result<Self, HttpError> {
-        let permission_manager = daemon
-            .get_permission_manager()
-            .await
-            .map_err(|e| HttpError::InternalServerError(e.to_string()))?;
-
-        let state_backend = daemon
-            .get_state_backend()
-            .await
-            .map_err(|e| HttpError::InternalServerError(e.to_string()))?;
-
-        let local_ctx = LocalContext::from_http_identity(&identity, state_backend.as_ref()).await;
-        let local_identity =
-            SubjectIdentity::new(identity.id.clone(), identity.source.clone(), local_ctx);
-
-        Ok(Self {
-            permission_manager,
-            state_backend,
-            identity,
-            local_identity,
-        })
-    }
-
-    /// Check if the user has permission to perform an action on an object
-    pub async fn check_permission(
-        &self,
-        action: Action,
-        object: &ObjectIdentity,
-    ) -> Result<(), HttpError> {
-        self.permission_manager
-            .check(&self.local_identity, action, object)
-            .await
-            .map_err(|e| {
-                tracing::debug!(
-                    "Permission denied for user {} on object {:?}: {}",
-                    self.identity.id,
-                    object,
-                    e
-                );
-                HttpError::AuthorizationFailed(format!("Insufficient permissions: {e}"))
-            })
-    }
-
-    /// Check if the user has admin permissions for a specific action
-    pub async fn require_admin(
-        &self,
-        action: Action,
-        object: &ObjectIdentity,
-    ) -> Result<(), HttpError> {
-        self.check_permission(action, object).await
-    }
-}
diff --git a/crates/daemon/src/helpers/errors.rs b/crates/daemon/src/helpers/errors.rs
deleted file mode 100644
index 8b44327d..00000000
--- a/crates/daemon/src/helpers/errors.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-//! Common error mapping utilities to reduce boilerplate
-
-use gate_http::error::HttpError;
-use std::fmt::Display;
-
-/// Extension trait for Result types to provide common error mappings
-pub trait ErrorMapExt<T> {
-    /// Map any error to an InternalServerError with a formatted message
-    fn map_internal_error(self) -> Result<T, HttpError>;
-
-    /// Map any error to an InternalServerError with a custom context
-    fn map_internal_error_with_context(self, context: &str) -> Result<T, HttpError>;
-}
-
-impl<T, E> ErrorMapExt<T> for Result<T, E>
-where
-    E: Display,
-{
-    fn map_internal_error(self) -> Result<T, HttpError> {
-        self.map_err(|e| HttpError::InternalServerError(e.to_string()))
-    }
-
-    fn map_internal_error_with_context(self, context: &str) -> Result<T, HttpError> {
-        self.map_err(|e| HttpError::InternalServerError(format!("{context}: {e}")))
-    }
-}
-
-/// Helper function to create a NotFound error
-pub fn not_found(entity: &str, id: &str) -> HttpError {
-    HttpError::NotFound(format!("{entity} '{id}' not found"))
-}
-
-/// Helper function to create a BadRequest error
-pub fn bad_request(message: impl Into<String>) -> HttpError {
-    HttpError::BadRequest(message.into())
-}
-
-/// Helper function to create an AuthorizationFailed error  
-pub fn authorization_failed(message: impl Into<String>) -> HttpError {
-    HttpError::AuthorizationFailed(message.into())
-}
diff --git a/crates/daemon/src/helpers/mod.rs b/crates/daemon/src/helpers/mod.rs
deleted file mode 100644
index 8208ef1f..00000000
--- a/crates/daemon/src/helpers/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-//! Helper modules to reduce code complexity and duplication
-
-pub mod admin;
-pub mod errors;
-pub mod services;
diff --git a/crates/daemon/src/helpers/services.rs b/crates/daemon/src/helpers/services.rs
deleted file mode 100644
index 0e9073b1..00000000
--- a/crates/daemon/src/helpers/services.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-//! Service access wrapper to simplify daemon service retrieval patterns
-
-use crate::daemon::Daemon;
-use gate_core::state::StateBackend;
-use gate_http::error::HttpError;
-use std::sync::Arc;
-
-/// Wrapper for commonly accessed daemon services
-pub struct ServiceAccessor<'a> {
-    daemon: &'a Daemon,
-}
-
-impl<'a> ServiceAccessor<'a> {
-    /// Create a new service accessor
-    pub fn new(daemon: &'a Daemon) -> Self {
-        Self { daemon }
-    }
-
-    /// Get the permission manager with standard error handling
-    pub async fn permission_manager(
-        &self,
-    ) -> Result<Arc<crate::permissions::LocalPermissionManager>, HttpError> {
-        self.daemon.get_permission_manager().await.map_err(|e| {
-            HttpError::InternalServerError(format!("Failed to get permission manager: {e}"))
-        })
-    }
-
-    /// Get the state backend with standard error handling
-    pub async fn state_backend(&self) -> Result<Arc<dyn StateBackend>, HttpError> {
-        self.daemon.get_state_backend().await.map_err(|e| {
-            HttpError::InternalServerError(format!("Failed to get state backend: {e}"))
-        })
-    }
-
-    /// Get both permission manager and state backend (common pattern)
-    pub async fn core_services(
-        &self,
-    ) -> Result<
-        (
-            Arc<crate::permissions::LocalPermissionManager>,
-            Arc<dyn StateBackend>,
-        ),
-        HttpError,
-    > {
-        let permission_manager = self.permission_manager().await?;
-        let state_backend = self.state_backend().await?;
-        Ok((permission_manager, state_backend))
-    }
-}
diff --git a/crates/daemon/src/lib.rs b/crates/daemon/src/lib.rs
deleted file mode 100644
index a0a7d563..00000000
--- a/crates/daemon/src/lib.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-#[macro_use]
-extern crate tracing;
-
-pub mod bootstrap;
-pub mod config;
-pub mod context;
-pub mod daemon;
-pub mod error;
-pub mod helpers;
-pub mod permissions;
-pub mod routes;
-pub mod services;
-pub mod sinks;
-pub mod state;
-pub mod state_dir;
-pub mod tls_reload;
-pub mod types;
-
-pub use config::Settings;
-pub use context::NativeRequestContext;
-pub use daemon::Daemon;
-pub use error::{DaemonError, Result};
-pub use state::State;
-pub use state_dir::StateDir;
-pub use types::{DaemonStatus, TlsForwardStatus};
diff --git a/crates/daemon/src/main.rs b/crates/daemon/src/main.rs
deleted file mode 100644
index 5598f6e6..00000000
--- a/crates/daemon/src/main.rs
+++ /dev/null
@@ -1,140 +0,0 @@
-#[macro_use]
-extern crate tracing;
-
-use anyhow::Result;
-use clap::Parser;
-use gate_core::tracing::{
-    config::{InstrumentationConfig, OtlpConfig},
-    init::init_tracing,
-};
-use gate_daemon::{Daemon, Settings, StateDir};
-
-/// Gate daemon - High-performance AI gateway
-#[derive(Parser, Debug)]
-#[command(author, version, about, long_about = None)]
-struct Cli {
-    /// Configuration file path
-    #[arg(short = 'c', long = "config")]
-    config: Option<String>,
-}
-
-#[tokio::main]
-async fn main() -> Result<()> {
-    // Initialize rustls crypto provider for TLS connections
-    rustls::crypto::ring::default_provider()
-        .install_default()
-        .expect("Failed to install rustls crypto provider");
-
-    // Parse command line arguments
-    let cli = Cli::parse();
-
-    // Load environment variables from .env file
-    dotenvy::dotenv().ok();
-
-    // Initialize instrumentation
-    let instrumentation_config = InstrumentationConfig {
-        service_name: "gate-daemon".to_string(),
-        service_version: env!("CARGO_PKG_VERSION").to_string(),
-        log_level: std::env::var("RUST_LOG")
-            .unwrap_or_else(|_| "gate=debug,tower_http=debug".to_string()),
-        otlp: std::env::var("OTLP_ENDPOINT")
-            .ok()
-            .map(|endpoint| OtlpConfig {
-                endpoint,
-                headers: None,
-            }),
-    };
-    init_tracing(&instrumentation_config)?;
-
-    // Build daemon
-    let mut builder = Daemon::builder();
-    let state_dir = StateDir::new().await?;
-    let default_config_path = state_dir.config_path();
-
-    // Load configuration if specified
-    if let Some(config_path) = cli.config {
-        debug!("Loading configuration from: {}", config_path);
-        let settings = Settings::load_from_file(&config_path)?;
-        builder = builder.with_settings(settings);
-    } else {
-        debug!(
-            "No configuration path specified, using default at {}",
-            default_config_path.display()
-        );
-        if default_config_path.exists() {
-            debug!(
-                "Loading configuration from default path: {}",
-                default_config_path.display()
-            );
-            builder = builder.with_settings(Settings::load_from_file(&default_config_path)?);
-        } else {
-            warn!("No configuration found, creating one using default settings");
-            let settings = Settings::default();
-            settings.save_to_file(&default_config_path).await?;
-            builder = builder.with_settings(settings);
-        }
-    }
-
-    // Pass state_dir to builder
-    builder = builder.with_state_dir(state_dir);
-
-    // Set static directory if specified
-    if let Ok(static_dir) = std::env::var("GATE_SERVER__STATIC_DIR") {
-        info!("Using static directory from environment: {}", static_dir);
-        builder = builder.with_static_dir(static_dir);
-    } else {
-        builder = builder.with_static_dir("crates/frontend-daemon/dist".to_string());
-    }
-
-    // Build the daemon
-    let daemon = builder.build().await?;
-
-    // Print startup information
-    let bootstrap_manager = daemon.get_bootstrap_manager().await?;
-    if let Some(token) = bootstrap_manager.get_token().await {
-        println!("\n===========================================");
-        println!("First-time setup required!");
-        println!("Please visit the following URL to create your admin account:");
-        println!(
-            "\n  http://localhost:{}/bootstrap/{}",
-            daemon
-                .server_address()
-                .await?
-                .split(':')
-                .nth(1)
-                .unwrap_or("31145"),
-            token
-        );
-        println!("\n===========================================\n");
-        info!("Bootstrap URL printed for token: {}", token);
-    } else {
-        println!("\n===========================================");
-        println!("Gate daemon is running");
-        println!("\n  URL: http://{}/", daemon.server_address().await?);
-        let user_count = daemon.user_count().await?;
-        if user_count == 1 {
-            println!("  Users: {user_count} registered user");
-        } else {
-            println!("  Users: {user_count} registered users");
-        }
-        println!("\n  Login with your passkey to access the admin panel");
-        println!("===========================================\n");
-    }
-
-    // Spawn server task
-    let daemon_clone = daemon.clone();
-    let _server_handle = tokio::spawn(async move {
-        if let Err(e) = daemon_clone.serve().await {
-            tracing::error!("Server error: {}", e);
-        }
-    });
-
-    // Wait for Ctrl+C
-    tokio::signal::ctrl_c().await?;
-    info!("Received shutdown signal");
-
-    // Graceful shutdown
-    daemon.system_identity().shutdown().await?;
-
-    Ok(())
-}
diff --git a/crates/daemon/src/permissions.rs b/crates/daemon/src/permissions.rs
deleted file mode 100644
index da14c263..00000000
--- a/crates/daemon/src/permissions.rs
+++ /dev/null
@@ -1,164 +0,0 @@
-use async_trait::async_trait;
-use gate_core::StateBackend;
-use gate_core::access::{
-    Action, IdentityContext, ObjectIdentity, PermissionDenied, PermissionManager, PermissionResult,
-    Permissions, SubjectIdentity,
-};
-use gate_http::services::identity::HttpIdentity;
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::sync::Arc;
-
-/// Local context for self-hosted deployments
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct LocalContext {
-    pub is_owner: bool,
-    pub node_id: String,
-}
-
-impl IdentityContext for LocalContext {
-    fn to_attributes(&self) -> HashMap<String, String> {
-        let mut attrs = HashMap::new();
-        attrs.insert("node_id".to_string(), self.node_id.clone());
-        attrs.insert("is_owner".to_string(), self.is_owner.to_string());
-        attrs
-    }
-
-    fn get(&self, key: &str) -> Option<&str> {
-        match key {
-            "node_id" => Some(&self.node_id),
-            "is_owner" => Some(if self.is_owner { "true" } else { "false" }),
-            _ => None,
-        }
-    }
-}
-
-impl LocalContext {
-    /// Convert from HTTP identity to local context
-    pub async fn from_http_identity(identity: &HttpIdentity, backend: &dyn StateBackend) -> Self {
-        // Honor explicit owner attribute if present
-        let is_owner = if matches!(identity.context.get("is_owner"), Some("true")) {
-            true
-        } else {
-            // Check if this is the first user (owner) via backend permission
-            backend
-                .has_permission(
-                    &identity.id,
-                    &Action::GrantPermission,
-                    &ObjectIdentity::wildcard(),
-                )
-                .await
-                .unwrap_or(false)
-        };
-
-        Self {
-            is_owner,
-            node_id: identity
-                .context
-                .get("node_id")
-                .unwrap_or("local")
-                .to_string(),
-        }
-    }
-}
-
-pub type LocalIdentity = SubjectIdentity<LocalContext>;
-
-pub struct LocalPermissionManager {
-    backend: Arc<dyn StateBackend>,
-}
-
-impl LocalPermissionManager {
-    pub fn new(backend: Arc<dyn StateBackend>) -> Self {
-        Self { backend }
-    }
-
-    /// Initialize the first user as owner with all permissions
-    pub async fn initialize_owner(&self, owner_id: &str) -> Result<(), PermissionDenied> {
-        self.store_permission_unchecked(
-            owner_id,
-            Action::GrantPermission,
-            &ObjectIdentity::wildcard(),
-        )
-        .await?;
-        self.store_permission_unchecked(owner_id, Action::Manage, &ObjectIdentity::wildcard())
-            .await?;
-        Ok(())
-    }
-}
-
-#[async_trait]
-impl Permissions<LocalContext> for LocalPermissionManager {
-    async fn check(
-        &self,
-        subject: &SubjectIdentity<LocalContext>,
-        action: Action,
-        object: &ObjectIdentity,
-    ) -> PermissionResult {
-        if subject.context.is_owner {
-            return Ok(());
-        }
-
-        // Check database for specific permission
-        match self
-            .backend
-            .has_permission(&subject.id, &action, object)
-            .await
-        {
-            Ok(true) => Ok(()),
-            Ok(false) => Err(PermissionDenied::NotAuthorized),
-            Err(e) => Err(PermissionDenied::Custom(format!("Database error: {e}"))),
-        }
-    }
-}
-
-#[async_trait]
-impl PermissionManager<LocalContext> for LocalPermissionManager {
-    async fn grant(
-        &self,
-        granter: &SubjectIdentity<LocalContext>,
-        grantee: &SubjectIdentity<LocalContext>,
-        action: Action,
-        object: &ObjectIdentity,
-    ) -> PermissionResult {
-        self.check(granter, Action::GrantPermission, object).await?;
-        self.store_permission_unchecked(&grantee.id, action, object)
-            .await
-    }
-
-    async fn revoke(
-        &self,
-        revoker: &SubjectIdentity<LocalContext>,
-        subject: &SubjectIdentity<LocalContext>,
-        action: Action,
-        object: &ObjectIdentity,
-    ) -> PermissionResult {
-        self.check(revoker, Action::RevokePermission, object)
-            .await?;
-
-        match self
-            .backend
-            .remove_permission(&subject.id, &action, object)
-            .await
-        {
-            Ok(_) => Ok(()),
-            Err(e) => Err(PermissionDenied::Custom(format!("Failed to revoke: {e}"))),
-        }
-    }
-
-    async fn store_permission_unchecked(
-        &self,
-        subject_id: &str,
-        action: Action,
-        object: &ObjectIdentity,
-    ) -> Result<(), PermissionDenied> {
-        match self
-            .backend
-            .grant_permission(subject_id, &action, object)
-            .await
-        {
-            Ok(_) => Ok(()),
-            Err(e) => Err(PermissionDenied::Custom(format!("Failed to store: {e}"))),
-        }
-    }
-}
diff --git a/crates/daemon/src/routes/admin.rs b/crates/daemon/src/routes/admin.rs
deleted file mode 100644
index 614b5e7b..00000000
--- a/crates/daemon/src/routes/admin.rs
+++ /dev/null
@@ -1,549 +0,0 @@
-//! Admin user management routes - refactored version
-
-use crate::helpers::{admin::AdminPermissionHelper, errors::ErrorMapExt};
-use axum::{
-    Router,
-    extract::{Path, State},
-    response::Json,
-    routing::{get, patch},
-};
-use gate_core::access::{
-    Action, ObjectId, ObjectIdentity, ObjectKind, PermissionManager, TargetNamespace,
-};
-use gate_core::types::User;
-use gate_http::{AppState, error::HttpError, services::HttpIdentity};
-use serde::{Deserialize, Serialize};
-
-// Re-use existing type definitions
-#[derive(Debug, Serialize, Deserialize)]
-pub struct UserListResponse {
-    pub users: Vec<UserInfo>,
-    pub total: usize,
-    pub page: usize,
-    pub page_size: usize,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct UserInfo {
-    pub id: String,
-    pub name: Option<String>,
-    pub enabled: bool,
-    pub created_at: chrono::DateTime<chrono::Utc>,
-    pub updated_at: chrono::DateTime<chrono::Utc>,
-    pub disabled_at: Option<chrono::DateTime<chrono::Utc>>,
-}
-
-impl From<User> for UserInfo {
-    fn from(user: User) -> Self {
-        let enabled = user.is_enabled();
-        UserInfo {
-            id: user.id,
-            name: user.name,
-            enabled,
-            created_at: user.created_at,
-            updated_at: user.updated_at,
-            disabled_at: user.disabled_at,
-        }
-    }
-}
-
-#[derive(Debug, Deserialize)]
-pub struct ListUsersQuery {
-    #[serde(default = "default_page")]
-    pub page: usize,
-    #[serde(default = "default_page_size")]
-    pub page_size: usize,
-    pub search: Option<String>,
-}
-
-fn default_page() -> usize {
-    1
-}
-fn default_page_size() -> usize {
-    20
-}
-
-#[derive(Debug, Deserialize)]
-pub struct UpdateUserStatusRequest {
-    pub enabled: bool,
-}
-
-#[derive(Debug, Serialize)]
-pub struct UpdateUserStatusResponse {
-    pub user: UserInfo,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct UserPermission {
-    pub action: String,
-    pub object: String,
-    pub granted_at: chrono::DateTime<chrono::Utc>,
-}
-
-#[derive(Debug, Serialize)]
-pub struct UserPermissionsResponse {
-    pub permissions: Vec<UserPermission>,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct GrantPermissionRequest {
-    pub action: String,
-    pub object: String,
-}
-
-/// List all users (admin only)
-#[instrument(name = "list_users", skip(app_state), fields(page = %query.page, page_size = %query.page_size))]
-pub async fn list_users(
-    identity: HttpIdentity,
-    State(app_state): State<AppState<crate::State>>,
-    axum::extract::Query(query): axum::extract::Query<ListUsersQuery>,
-) -> Result<Json<UserListResponse>, HttpError> {
-    let helper = AdminPermissionHelper::new(&app_state.data.daemon, identity.clone()).await?;
-
-    // Check permission
-    helper
-        .require_admin(
-            Action::Read,
-            &ObjectIdentity {
-                namespace: TargetNamespace::System,
-                kind: ObjectKind::Users,
-                id: ObjectId::new("*"),
-            },
-        )
-        .await?;
-
-    // Get and filter users
-    let mut users = helper
-        .state_backend
-        .list_users()
-        .await
-        .map_internal_error()?;
-
-    if let Some(search) = &query.search {
-        let search_lower = search.to_lowercase();
-        users.retain(|u| {
-            u.id.to_lowercase().contains(&search_lower)
-                || u.name
-                    .as_ref()
-                    .is_some_and(|n| n.to_lowercase().contains(&search_lower))
-        });
-    }
-
-    let total = users.len();
-    let offset = (query.page.saturating_sub(1)) * query.page_size;
-
-    let users: Vec<UserInfo> = users
-        .into_iter()
-        .skip(offset)
-        .take(query.page_size)
-        .map(UserInfo::from)
-        .collect();
-
-    info!("Admin {} listed {} users", identity.id, users.len());
-
-    Ok(Json(UserListResponse {
-        users,
-        total,
-        page: query.page,
-        page_size: query.page_size,
-    }))
-}
-
-/// Get a specific user (admin only)
-#[instrument(name = "get_user", skip(app_state), fields(target_user_id = %user_id))]
-pub async fn get_user(
-    identity: HttpIdentity,
-    State(app_state): State<AppState<crate::State>>,
-    Path(user_id): Path<String>,
-) -> Result<Json<UserInfo>, HttpError> {
-    let helper = AdminPermissionHelper::new(&app_state.data.daemon, identity.clone()).await?;
-
-    helper
-        .require_admin(
-            Action::Read,
-            &ObjectIdentity {
-                namespace: TargetNamespace::System,
-                kind: ObjectKind::User,
-                id: ObjectId::new(user_id.clone()),
-            },
-        )
-        .await?;
-
-    let user = helper
-        .state_backend
-        .get_user(&user_id)
-        .await
-        .map_internal_error()?
-        .ok_or_else(|| HttpError::NotFound(format!("User {user_id} not found")))?;
-
-    info!("Admin {} retrieved user {}", identity.id, user_id);
-    Ok(Json(UserInfo::from(user)))
-}
-
-/// Delete a user (admin only)
-#[instrument(name = "delete_user", skip(app_state), fields(target_user_id = %user_id))]
-pub async fn delete_user(
-    identity: HttpIdentity,
-    State(app_state): State<AppState<crate::State>>,
-    Path(user_id): Path<String>,
-) -> Result<axum::http::StatusCode, HttpError> {
-    // Prevent self-deletion
-    if identity.id == user_id {
-        warn!("User {} attempted to delete themselves", identity.id);
-        return Err(HttpError::BadRequest(
-            "Cannot delete your own account".to_string(),
-        ));
-    }
-
-    let helper = AdminPermissionHelper::new(&app_state.data.daemon, identity.clone()).await?;
-
-    helper
-        .require_admin(
-            Action::Delete,
-            &ObjectIdentity {
-                namespace: TargetNamespace::System,
-                kind: ObjectKind::User,
-                id: ObjectId::new(user_id.clone()),
-            },
-        )
-        .await?;
-
-    // Check user exists
-    helper
-        .state_backend
-        .get_user(&user_id)
-        .await
-        .map_internal_error()?
-        .ok_or_else(|| HttpError::NotFound(format!("User {user_id} not found")))?;
-
-    // Delete user
-    helper
-        .state_backend
-        .delete_user(&user_id)
-        .await
-        .map_internal_error_with_context("Failed to delete user")?;
-
-    info!("Admin {} deleted user {}", identity.id, user_id);
-    Ok(axum::http::StatusCode::NO_CONTENT)
-}
-
-/// Update user status (enable/disable)
-#[instrument(name = "update_user_status", skip(app_state), fields(target_user_id = %user_id, enabled = %request.enabled))]
-pub async fn update_user_status(
-    identity: HttpIdentity,
-    State(app_state): State<AppState<crate::State>>,
-    Path(user_id): Path<String>,
-    Json(request): Json<UpdateUserStatusRequest>,
-) -> Result<Json<UpdateUserStatusResponse>, HttpError> {
-    // Prevent self-disable
-    if identity.id == user_id && !request.enabled {
-        warn!("User {} attempted to disable themselves", identity.id);
-        return Err(HttpError::BadRequest(
-            "Cannot disable your own account".to_string(),
-        ));
-    }
-
-    let helper = AdminPermissionHelper::new(&app_state.data.daemon, identity.clone()).await?;
-
-    helper
-        .require_admin(
-            Action::Write,
-            &ObjectIdentity {
-                namespace: TargetNamespace::System,
-                kind: ObjectKind::User,
-                id: ObjectId::new(user_id.clone()),
-            },
-        )
-        .await?;
-
-    // Get and update user
-    let mut user = helper
-        .state_backend
-        .get_user(&user_id)
-        .await
-        .map_internal_error()?
-        .ok_or_else(|| HttpError::NotFound(format!("User {user_id} not found")))?;
-
-    if request.enabled {
-        user.disabled_at = None;
-    } else {
-        user.disabled_at = Some(chrono::Utc::now());
-    }
-    user.updated_at = chrono::Utc::now();
-
-    helper
-        .state_backend
-        .update_user(&user)
-        .await
-        .map_internal_error_with_context("Failed to update user status")?;
-
-    info!(
-        "Admin {} {} user {}",
-        identity.id,
-        if request.enabled {
-            "enabled"
-        } else {
-            "disabled"
-        },
-        user_id
-    );
-
-    Ok(Json(UpdateUserStatusResponse {
-        user: UserInfo::from(user),
-    }))
-}
-
-/// Get user permissions
-#[instrument(name = "get_user_permissions", skip(app_state), fields(target_user_id = %user_id))]
-pub async fn get_user_permissions(
-    identity: HttpIdentity,
-    State(app_state): State<AppState<crate::State>>,
-    Path(user_id): Path<String>,
-) -> Result<Json<UserPermissionsResponse>, HttpError> {
-    let helper = AdminPermissionHelper::new(&app_state.data.daemon, identity.clone()).await?;
-
-    helper
-        .require_admin(
-            Action::ViewPermissions,
-            &ObjectIdentity {
-                namespace: TargetNamespace::System,
-                kind: ObjectKind::User,
-                id: ObjectId::new(user_id.clone()),
-            },
-        )
-        .await?;
-
-    // Check user exists
-    helper
-        .state_backend
-        .get_user(&user_id)
-        .await
-        .map_internal_error()?
-        .ok_or_else(|| HttpError::NotFound(format!("User {user_id} not found")))?;
-
-    let permissions = helper
-        .state_backend
-        .list_user_permissions(&user_id)
-        .await
-        .map_internal_error()?
-        .into_iter()
-        .map(|(action, object, granted_at)| UserPermission {
-            action,
-            object,
-            granted_at,
-        })
-        .collect();
-
-    Ok(Json(UserPermissionsResponse { permissions }))
-}
-
-/// Grant permission to user
-#[instrument(name = "grant_user_permission", skip(app_state), fields(target_user_id = %user_id, action = %request.action, object = %request.object))]
-pub async fn grant_user_permission(
-    identity: HttpIdentity,
-    State(app_state): State<AppState<crate::State>>,
-    Path(user_id): Path<String>,
-    Json(request): Json<GrantPermissionRequest>,
-) -> Result<axum::http::StatusCode, HttpError> {
-    let helper = AdminPermissionHelper::new(&app_state.data.daemon, identity.clone()).await?;
-
-    helper
-        .require_admin(
-            Action::GrantPermission,
-            &ObjectIdentity {
-                namespace: TargetNamespace::System,
-                kind: ObjectKind::User,
-                id: ObjectId::new(user_id.clone()),
-            },
-        )
-        .await?;
-
-    // Check user exists
-    helper
-        .state_backend
-        .get_user(&user_id)
-        .await
-        .map_internal_error()?
-        .ok_or_else(|| HttpError::NotFound(format!("User {user_id} not found")))?;
-
-    // Parse action and object
-    let action = parse_action(&request.action)
-        .ok_or_else(|| HttpError::BadRequest(format!("Invalid action: {}", request.action)))?;
-
-    let object = parse_object_identity(&request.object).ok_or_else(|| {
-        HttpError::BadRequest(format!("Invalid object format: {}", request.object))
-    })?;
-
-    // Create identity for the user receiving the permission
-    let grantee_user = helper
-        .state_backend
-        .get_user(&user_id)
-        .await
-        .map_internal_error()?
-        .ok_or_else(|| HttpError::NotFound(format!("User {user_id} not found")))?;
-
-    let grantee_identity = gate_core::access::SubjectIdentity::new(
-        grantee_user.id.clone(),
-        "user",
-        crate::permissions::LocalContext {
-            is_owner: false,
-            node_id: "local".to_string(),
-        },
-    );
-
-    helper
-        .permission_manager
-        .grant(&helper.local_identity, &grantee_identity, action, &object)
-        .await
-        .map_internal_error_with_context("Failed to grant permission")?;
-
-    info!(
-        "Admin {} granted {} permission on {} to user {}",
-        identity.id, request.action, request.object, user_id
-    );
-
-    Ok(axum::http::StatusCode::CREATED)
-}
-
-/// Revoke permission from user
-#[instrument(name = "revoke_user_permission", skip(app_state))]
-pub async fn revoke_user_permission(
-    identity: HttpIdentity,
-    State(app_state): State<AppState<crate::State>>,
-    Path(user_id): Path<String>,
-    axum::extract::Query(params): axum::extract::Query<std::collections::HashMap<String, String>>,
-) -> Result<axum::http::StatusCode, HttpError> {
-    let action = params
-        .get("action")
-        .ok_or_else(|| HttpError::BadRequest("Missing action parameter".to_string()))?;
-    let object = params
-        .get("object")
-        .ok_or_else(|| HttpError::BadRequest("Missing object parameter".to_string()))?;
-
-    let helper = AdminPermissionHelper::new(&app_state.data.daemon, identity.clone()).await?;
-
-    helper
-        .require_admin(
-            Action::RevokePermission,
-            &ObjectIdentity {
-                namespace: TargetNamespace::System,
-                kind: ObjectKind::User,
-                id: ObjectId::new(user_id.clone()),
-            },
-        )
-        .await?;
-
-    // Check user exists and get their identity
-    let target_user = helper
-        .state_backend
-        .get_user(&user_id)
-        .await
-        .map_internal_error()?
-        .ok_or_else(|| HttpError::NotFound(format!("User {user_id} not found")))?;
-
-    // Parse action and object
-    let action_enum = parse_action(action)
-        .ok_or_else(|| HttpError::BadRequest(format!("Invalid action: {action}")))?;
-
-    let object_identity = parse_object_identity(object)
-        .ok_or_else(|| HttpError::BadRequest(format!("Invalid object format: {object}")))?;
-
-    // Create identity for the user losing the permission
-    let subject_identity = gate_core::access::SubjectIdentity::new(
-        target_user.id.clone(),
-        "user",
-        crate::permissions::LocalContext {
-            is_owner: false,
-            node_id: "local".to_string(),
-        },
-    );
-
-    helper
-        .permission_manager
-        .revoke(
-            &helper.local_identity,
-            &subject_identity,
-            action_enum,
-            &object_identity,
-        )
-        .await
-        .map_internal_error_with_context("Failed to revoke permission")?;
-
-    info!(
-        "Admin {} revoked {} permission on {} from user {}",
-        identity.id, action, object, user_id
-    );
-
-    Ok(axum::http::StatusCode::NO_CONTENT)
-}
-
-// Helper function to parse action string
-fn parse_action(s: &str) -> Option<Action> {
-    match s {
-        "read" | "Read" => Some(Action::Read),
-        "write" | "Write" => Some(Action::Write),
-        "delete" | "Delete" => Some(Action::Delete),
-        "execute" | "Execute" => Some(Action::Execute),
-        "manage" | "Manage" => Some(Action::Manage),
-        "grant_permission" | "GrantPermission" => Some(Action::GrantPermission),
-        "revoke_permission" | "RevokePermission" => Some(Action::RevokePermission),
-        "view_permissions" | "ViewPermissions" => Some(Action::ViewPermissions),
-        "view_quota" | "ViewQuota" => Some(Action::ViewQuota),
-        "update_quota" | "UpdateQuota" => Some(Action::UpdateQuota),
-        _ => None,
-    }
-}
-
-// Helper function to parse object identity string
-fn parse_object_identity(s: &str) -> Option<ObjectIdentity> {
-    let parts: Vec<&str> = s.split('/').collect();
-    if parts.len() != 3 {
-        return None;
-    }
-
-    let namespace = match parts[0] {
-        "system" => TargetNamespace::System,
-        "local" => TargetNamespace::Local,
-        _ => return None,
-    };
-
-    let kind = match parts[1] {
-        "model" => ObjectKind::Model,
-        "provider" => ObjectKind::Provider,
-        "user" => ObjectKind::User,
-        "users" => ObjectKind::Users,
-        "config" => ObjectKind::Config,
-        "billing" => ObjectKind::Billing,
-        "system" => ObjectKind::System,
-        "quota" => ObjectKind::Quota,
-        _ => return None,
-    };
-
-    Some(ObjectIdentity {
-        namespace,
-        kind,
-        id: ObjectId::new(parts[2]),
-    })
-}
-
-/// Add admin routes
-pub fn add_routes(
-    router: Router<gate_http::AppState<crate::State>>,
-) -> Router<gate_http::AppState<crate::State>> {
-    router
-        .route("/api/admin/users", get(list_users))
-        .route(
-            "/api/admin/users/{user_id}",
-            get(get_user).delete(delete_user),
-        )
-        .route(
-            "/api/admin/users/{user_id}/status",
-            patch(update_user_status),
-        )
-        .route(
-            "/api/admin/users/{user_id}/permissions",
-            get(get_user_permissions)
-                .post(grant_user_permission)
-                .delete(revoke_user_permission),
-        )
-}
diff --git a/crates/daemon/src/routes/auth.rs b/crates/daemon/src/routes/auth.rs
deleted file mode 100644
index 09da7f27..00000000
--- a/crates/daemon/src/routes/auth.rs
+++ /dev/null
@@ -1,352 +0,0 @@
-//! Custom authentication routes with registration control
-
-use crate::types::BootstrapStatusResponse;
-use axum::{
-    Router,
-    routing::{get, post},
-};
-use axum::{extract::State, response::Json};
-use chrono::{DateTime, Utc};
-use gate_core::User;
-use gate_http::{
-    error::HttpError,
-    services::HttpIdentity,
-    types::{
-        AuthCompleteRequest, AuthCompleteResponse, AuthStartResponse, RegisterCompleteRequest,
-        RegisterCompleteResponse, RegisterStartRequest, RegisterStartResponse,
-    },
-};
-
-/// Check bootstrap status
-#[instrument(name = "get_bootstrap_status", skip(state))]
-pub async fn get_bootstrap_status(
-    State(state): State<gate_http::AppState<crate::State>>,
-) -> Result<Json<BootstrapStatusResponse>, HttpError> {
-    let bootstrap_manager = state
-        .data
-        .daemon
-        .get_bootstrap_manager()
-        .await
-        .map_err(|e| HttpError::InternalServerError(e.to_string()))?;
-
-    let needs_bootstrap = bootstrap_manager.needs_bootstrap().await.map_err(|e| {
-        HttpError::InternalServerError(format!("Failed to check bootstrap status: {e}"))
-    })?;
-
-    let is_complete = bootstrap_manager.is_bootstrap_complete().await;
-
-    Ok(Json(BootstrapStatusResponse {
-        needs_bootstrap,
-        is_complete,
-        message: if needs_bootstrap {
-            "System requires initial admin user setup".to_string()
-        } else {
-            "System is bootstrapped".to_string()
-        },
-    }))
-}
-
-#[derive(serde::Serialize, serde::Deserialize)]
-pub struct CurrentUser {
-    pub id: String,
-    pub name: Option<String>,
-    pub created_at: DateTime<Utc>,
-    pub updated_at: DateTime<Utc>,
-}
-
-impl From<User> for CurrentUser {
-    fn from(user: User) -> Self {
-        Self {
-            id: user.id,
-            name: user.name,
-            created_at: user.created_at,
-            updated_at: user.updated_at,
-        }
-    }
-}
-
-/// Complete WebAuthn registration with bootstrap token validation
-/// This endpoint is specifically for the first-time setup with a bootstrap token
-/// Complete WebAuthn registration with bootstrap token validation (first-time setup)
-#[instrument(
-    name = "bootstrap_register",
-    skip(state, request),
-    fields(
-        session_id = %request.session_id,
-        device_name = ?request.device_name
-    )
-)]
-pub async fn register_with_bootstrap(
-    State(state): State<gate_http::AppState<crate::State>>,
-    Json(request): Json<RegisterCompleteRequest>,
-) -> Result<Json<RegisterCompleteResponse>, HttpError> {
-    // Get services from daemon
-    let webauthn_service = state
-        .data
-        .daemon
-        .get_webauthn_service()
-        .await
-        .map_err(|e| HttpError::InternalServerError(e.to_string()))?
-        .ok_or_else(|| HttpError::BadRequest("WebAuthn service not enabled".to_string()))?;
-    let bootstrap_manager = state
-        .data
-        .daemon
-        .get_bootstrap_manager()
-        .await
-        .map_err(|e| HttpError::InternalServerError(e.to_string()))?;
-    let permission_manager = state
-        .data
-        .daemon
-        .get_permission_manager()
-        .await
-        .map_err(|e| HttpError::InternalServerError(e.to_string()))?;
-
-    // Auth service is available directly from state for performance
-    let auth_service = &state.data.auth_service;
-
-    // Bootstrap token is required for this endpoint
-    let token = request.bootstrap_token.as_ref().ok_or_else(|| {
-        HttpError::AuthorizationFailed("Bootstrap token is required for this endpoint".to_string())
-    })?;
-
-    info!("Bootstrap registration attempt with token: {}", token);
-
-    // Check if bootstrap is still needed
-    let needs_bootstrap = bootstrap_manager.needs_bootstrap().await.unwrap_or(true);
-    info!("Bootstrap needed: {}", needs_bootstrap);
-
-    if !needs_bootstrap {
-        return Err(HttpError::AuthorizationFailed(
-            "Bootstrap already completed".to_string(),
-        ));
-    }
-
-    // Validate the bootstrap token
-    let token_valid = bootstrap_manager
-        .validate_token(token)
-        .await
-        .unwrap_or(false);
-    info!("Bootstrap token validation result: {}", token_valid);
-
-    if !token_valid {
-        warn!("Invalid bootstrap token provided during registration");
-        return Err(HttpError::AuthorizationFailed(
-            "Invalid bootstrap token".to_string(),
-        ));
-    }
-
-    // Complete the WebAuthn registration
-    let device_name = request.device_name.clone();
-    let (passkey, credential_id, user_name) = webauthn_service
-        .complete_registration(request.session_id.clone(), request.credential.clone())
-        .await?;
-
-    let user = User {
-        id: credential_id.clone(),
-        name: Some(user_name.clone()),
-        created_at: Utc::now(),
-        updated_at: Utc::now(),
-        disabled_at: None,
-        metadata: std::collections::HashMap::new(),
-    };
-
-    // Register the user using the common auth service
-    let response = auth_service
-        .complete_registration(user, credential_id.clone(), device_name, passkey)
-        .await?;
-
-    // Grant admin permissions to the bootstrap user
-    info!("Granting admin permissions to user: {}", credential_id);
-    permission_manager
-        .initialize_owner(&credential_id)
-        .await
-        .map_err(|e| {
-            HttpError::InternalServerError(format!("Failed to grant admin permissions: {e}"))
-        })?;
-    info!("Admin permissions granted successfully");
-
-    // Mark bootstrap token as used
-    bootstrap_manager.mark_as_used().await.map_err(|e| {
-        HttpError::InternalServerError(format!("Failed to mark bootstrap token as used: {e}"))
-    })?;
-
-    info!(
-        "Bootstrap user registered with admin permissions: {} ({})",
-        response.name, response.user_id
-    );
-
-    Ok(Json(response))
-}
-
-/// Start WebAuthn registration
-#[instrument(
-    name = "webauthn_register_start",
-    skip(state),
-    fields(
-        user_name = %request.name
-    )
-)]
-pub async fn register_start(
-    State(state): State<gate_http::AppState<crate::State>>,
-    Json(request): Json<RegisterStartRequest>,
-) -> Result<Json<RegisterStartResponse>, HttpError> {
-    let webauthn_service = state
-        .data
-        .daemon
-        .get_webauthn_service()
-        .await
-        .map_err(|e| HttpError::InternalServerError(e.to_string()))?
-        .ok_or_else(|| HttpError::BadRequest("WebAuthn service not enabled".to_string()))?;
-
-    let (challenge, session_id) = webauthn_service.start_registration(request.name).await?;
-
-    Ok(Json(RegisterStartResponse {
-        challenge,
-        session_id,
-    }))
-}
-
-/// Complete WebAuthn registration
-#[instrument(
-    name = "webauthn_register_complete",
-    skip(state, request),
-    fields(
-        session_id = %request.session_id,
-        device_name = ?request.device_name,
-        has_bootstrap_token = request.bootstrap_token.is_some()
-    )
-)]
-pub async fn register_complete(
-    State(state): State<gate_http::AppState<crate::State>>,
-    Json(request): Json<RegisterCompleteRequest>,
-) -> Result<Json<RegisterCompleteResponse>, HttpError> {
-    let webauthn_service = state
-        .data
-        .daemon
-        .get_webauthn_service()
-        .await
-        .map_err(|e| HttpError::InternalServerError(e.to_string()))?
-        .ok_or_else(|| HttpError::BadRequest("WebAuthn service not enabled".to_string()))?;
-
-    let auth_service = &state.data.auth_service;
-
-    let device_name = request.device_name.clone();
-    let (passkey, credential_id, user_name) = webauthn_service
-        .complete_registration(request.session_id, request.credential)
-        .await?;
-
-    let user = User {
-        id: credential_id.clone(),
-        name: Some(user_name.clone()),
-        created_at: Utc::now(),
-        updated_at: Utc::now(),
-        disabled_at: None,
-        metadata: std::collections::HashMap::new(),
-    };
-
-    let response = auth_service
-        .complete_registration(user, credential_id.clone(), device_name, passkey)
-        .await?;
-
-    info!("User registered: {} ({})", response.name, response.user_id);
-
-    Ok(Json(response))
-}
-
-/// Start WebAuthn authentication
-#[instrument(name = "webauthn_auth_start", skip(state))]
-pub async fn auth_start(
-    State(state): State<gate_http::AppState<crate::State>>,
-) -> Result<Json<AuthStartResponse>, HttpError> {
-    let webauthn_service = state
-        .data
-        .daemon
-        .get_webauthn_service()
-        .await
-        .map_err(|e| HttpError::InternalServerError(e.to_string()))?
-        .ok_or_else(|| HttpError::BadRequest("WebAuthn service not enabled".to_string()))?;
-
-    let (challenge, session_id) = webauthn_service.start_authentication().await?;
-
-    Ok(Json(AuthStartResponse {
-        challenge,
-        session_id,
-    }))
-}
-
-/// Complete WebAuthn authentication
-#[instrument(
-    name = "webauthn_auth_complete",
-    skip(state, request),
-    fields(
-        session_id = %request.session_id
-    )
-)]
-pub async fn auth_complete(
-    State(state): State<gate_http::AppState<crate::State>>,
-    Json(request): Json<AuthCompleteRequest>,
-) -> Result<Json<AuthCompleteResponse>, HttpError> {
-    let webauthn_service = state
-        .data
-        .daemon
-        .get_webauthn_service()
-        .await
-        .map_err(|e| HttpError::InternalServerError(e.to_string()))?
-        .ok_or_else(|| HttpError::BadRequest("WebAuthn service not enabled".to_string()))?;
-
-    let auth_service = &state.data.auth_service;
-
-    let (credential_id, counter) = webauthn_service
-        .complete_authentication(request.session_id, request.credential)
-        .await?;
-
-    let response = auth_service
-        .complete_authentication(credential_id.clone(), counter)
-        .await?;
-
-    info!(
-        "User authenticated: {} ({})",
-        response.name, response.user_id
-    );
-
-    Ok(Json(response))
-}
-
-/// Get current user information
-async fn get_current_user(
-    State(state): State<gate_http::AppState<crate::State>>,
-    identity: HttpIdentity,
-) -> Result<Json<CurrentUser>, HttpError> {
-    // Get user from database via daemon
-    let state_backend = state
-        .data
-        .daemon
-        .get_state_backend()
-        .await
-        .map_err(|e| HttpError::InternalServerError(e.to_string()))?;
-
-    let user_data = state_backend
-        .get_user(&identity.id)
-        .await
-        .map_err(|e| HttpError::InternalServerError(format!("Failed to get user: {e}")))?
-        .ok_or_else(|| HttpError::AuthorizationFailed("User not found".to_string()))?;
-
-    Ok(Json(user_data.into()))
-}
-
-/// Add custom auth routes
-pub fn add_routes(
-    router: Router<gate_http::AppState<crate::State>>,
-) -> Router<gate_http::AppState<crate::State>> {
-    router
-        .route("/auth/bootstrap/status", get(get_bootstrap_status))
-        .route(
-            "/auth/webauthn/register/bootstrap",
-            post(register_with_bootstrap),
-        )
-        .route("/auth/webauthn/register/start", post(register_start))
-        .route("/auth/webauthn/register/complete", post(register_complete))
-        .route("/auth/webauthn/authenticate/start", post(auth_start))
-        .route("/auth/webauthn/authenticate/complete", post(auth_complete))
-        .route("/api/auth/me", get(get_current_user))
-}
diff --git a/crates/daemon/src/routes/config.rs b/crates/daemon/src/routes/config.rs
deleted file mode 100644
index 0b5deea7..00000000
--- a/crates/daemon/src/routes/config.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-//! Configuration management routes
-
-use crate::Settings;
-use axum::{Router, extract, response, routing::get};
-use gate_http::{
-    error::HttpError,
-    services::HttpIdentity,
-    types::{ConfigResponse, ConfigUpdateRequest},
-};
-
-/// Get the full configuration
-pub async fn get_config(
-    identity: HttpIdentity,
-    extract::State(state): extract::State<gate_http::AppState<crate::State>>,
-) -> Result<response::Json<ConfigResponse>, HttpError> {
-    // Use daemon to get config with permission check
-    let settings = state
-        .data
-        .daemon
-        .clone()
-        .with_http_identity(&identity)
-        .await
-        .map_err(|e| HttpError::InternalServerError(e.to_string()))?
-        .get_config()
-        .await
-        .map_err(|e| HttpError::InternalServerError(e.to_string()))?;
-    let config = serde_json::to_value(settings)
-        .map_err(|e| HttpError::InternalServerError(e.to_string()))?;
-    Ok(response::Json(ConfigResponse { config }))
-}
-
-/// Update the full configuration
-pub async fn update_config(
-    identity: HttpIdentity,
-    extract::State(state): extract::State<gate_http::AppState<crate::State>>,
-    extract::Json(request): extract::Json<ConfigUpdateRequest>,
-) -> Result<response::Json<ConfigResponse>, HttpError> {
-    // Deserialize the new configuration
-    let new_config: Settings = serde_json::from_value(request.config.clone())
-        .map_err(|e| HttpError::BadRequest(format!("Invalid configuration: {e}")))?;
-
-    // Use daemon to update config with permission check
-    state
-        .data
-        .daemon
-        .clone()
-        .with_http_identity(&identity)
-        .await
-        .map_err(|e| HttpError::InternalServerError(e.to_string()))?
-        .update_config(new_config.clone())
-        .await
-        .map_err(|e| HttpError::InternalServerError(e.to_string()))?;
-    let config = serde_json::to_value(new_config)
-        .map_err(|e| HttpError::InternalServerError(e.to_string()))?;
-    Ok(response::Json(ConfigResponse { config }))
-}
-
-/// Add config routes to a router
-pub fn add_routes(
-    router: Router<gate_http::AppState<crate::State>>,
-) -> Router<gate_http::AppState<crate::State>> {
-    router.route("/api/config", get(get_config).put(update_config))
-}
diff --git a/crates/daemon/src/routes/mod.rs b/crates/daemon/src/routes/mod.rs
deleted file mode 100644
index 060705d5..00000000
--- a/crates/daemon/src/routes/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-pub mod admin;
-pub mod auth;
-pub mod config;
diff --git a/crates/daemon/src/services/auth.rs b/crates/daemon/src/services/auth.rs
deleted file mode 100644
index 8c59ee11..00000000
--- a/crates/daemon/src/services/auth.rs
+++ /dev/null
@@ -1,126 +0,0 @@
-use chrono::Utc;
-use gate_core::{StateBackend, User};
-use gate_http::error::HttpError;
-use gate_http::services::{HttpContext, HttpIdentity, JwtService};
-use gate_http::types::{AuthCompleteResponse, RegisterCompleteResponse};
-use gate_sqlx::{SqliteWebAuthnBackend, StoredCredential};
-use std::sync::Arc;
-use webauthn_rs::prelude::*;
-
-/// Authentication service that coordinates JWT and WebAuthn operations
-pub struct AuthService {
-    jwt_service: Arc<JwtService>,
-    state_backend: Arc<dyn StateBackend>,
-    webauthn_backend: Arc<SqliteWebAuthnBackend>,
-}
-
-impl AuthService {
-    pub fn new(
-        jwt_service: Arc<JwtService>,
-        state_backend: Arc<dyn StateBackend>,
-        webauthn_backend: Arc<SqliteWebAuthnBackend>,
-    ) -> Self {
-        Self {
-            jwt_service,
-            state_backend,
-            webauthn_backend,
-        }
-    }
-
-    pub async fn complete_registration(
-        &self,
-        user: User,
-        credential_id: String,
-        device_name: Option<String>,
-        passkey: Passkey,
-    ) -> Result<RegisterCompleteResponse, HttpError> {
-        self.state_backend
-            .create_user(&user)
-            .await
-            .map_err(|e| HttpError::InternalServerError(format!("Failed to create user: {e}")))?;
-
-        let passkey_data = serde_json::to_vec(&passkey).map_err(|e| {
-            HttpError::InternalServerError(format!("Failed to serialize passkey: {e}"))
-        })?;
-
-        let stored_credential = StoredCredential {
-            credential_id: credential_id.clone(),
-            user_id: user.id.clone(),
-            public_key: passkey_data,
-            aaguid: None,
-            counter: 0,
-            created_at: Utc::now(),
-            last_used_at: None,
-            device_name,
-        };
-
-        self.webauthn_backend
-            .store_webauthn_credential(&stored_credential)
-            .await
-            .map_err(|e| {
-                HttpError::InternalServerError(format!("Failed to store credential: {e}"))
-            })?;
-
-        let token = self
-            .jwt_service
-            .generate_token(&user.id, user.name.as_deref())?;
-
-        Ok(RegisterCompleteResponse {
-            user_id: user.id.clone(),
-            name: user.name.unwrap_or_else(|| "User".to_string()),
-            credential_id,
-            token,
-        })
-    }
-
-    pub async fn complete_authentication(
-        &self,
-        credential_id: String,
-        counter: u32,
-    ) -> Result<AuthCompleteResponse, HttpError> {
-        let user = self
-            .state_backend
-            .get_user_by_id(&credential_id)
-            .await
-            .map_err(|e| HttpError::InternalServerError(format!("Failed to get user: {e}")))?
-            .ok_or_else(|| HttpError::NotFound("User not found".to_string()))?;
-
-        self.webauthn_backend
-            .update_credential_counter(&credential_id, counter)
-            .await
-            .map_err(|e| {
-                HttpError::InternalServerError(format!("Failed to update credential: {e}"))
-            })?;
-
-        let token = self
-            .jwt_service
-            .generate_token(&user.id, user.name.as_deref())?;
-
-        Ok(AuthCompleteResponse {
-            user_id: user.id,
-            name: user.name.unwrap_or_else(|| "User".to_string()),
-            token,
-        })
-    }
-
-    pub fn validate_token(&self, token: &str) -> Result<HttpIdentity, HttpError> {
-        let claims = self.jwt_service.validate_token(token)?;
-
-        let identity = HttpIdentity::new(
-            claims.sub.clone(),
-            "jwt".to_string(),
-            HttpContext::new()
-                .with_attribute("auth_method", "webauthn")
-                .with_attribute("issued_at", claims.iat.to_string())
-                .with_attribute("expires_at", claims.exp.to_string())
-                .with_attribute("name", claims.name.as_deref().unwrap_or("")),
-        );
-
-        Ok(identity)
-    }
-
-    pub fn authenticate_from_header(&self, auth_header: &str) -> Result<HttpIdentity, HttpError> {
-        let token = self.jwt_service.extract_bearer_token(auth_header)?;
-        self.validate_token(token)
-    }
-}
diff --git a/crates/daemon/src/services/inference.rs b/crates/daemon/src/services/inference.rs
deleted file mode 100644
index 45498995..00000000
--- a/crates/daemon/src/services/inference.rs
+++ /dev/null
@@ -1,566 +0,0 @@
-use crate::config::LocalInferenceConfig;
-use anyhow;
-use async_trait::async_trait;
-use gate_core::inference::{
-    AnthropicContent, AnthropicMessage, AnthropicMessageRequest, AnthropicMessageResponse,
-    AnthropicMessageStream, AnthropicUsage, ChatChoice, ChatCompletionRequest,
-    ChatCompletionResponse, ChatCompletionStream, ChatMessage, InferenceBackend, LocalModel, Usage,
-};
-use gate_core::{Error, Result};
-use std::collections::HashMap;
-use std::sync::Arc;
-use tokio::sync::{mpsc, oneshot};
-
-pub struct LocalInferenceService {
-    config: LocalInferenceConfig,
-    catgrad_worker: Option<Arc<catgrad::CatgradWorker>>,
-}
-
-impl LocalInferenceService {
-    pub fn new(config: LocalInferenceConfig) -> Result<Self> {
-        // Initialize catgrad worker if local inference is enabled
-        let catgrad_worker = if config.enabled {
-            debug!("Initializing catgrad worker for local inference");
-            match catgrad::CatgradWorker::new() {
-                Ok(worker) => Some(Arc::new(worker)),
-                Err(e) => {
-                    error!("Failed to initialize catgrad worker: {}", e);
-                    None
-                }
-            }
-        } else {
-            info!("Local inference is disabled");
-            None
-        };
-
-        Ok(Self {
-            config,
-            catgrad_worker,
-        })
-    }
-
-    fn convert_chat_to_prompt(&self, messages: &[ChatMessage]) -> String {
-        let mut prompt = String::new();
-
-        for message in messages {
-            match message.role.as_str() {
-                "system" => {
-                    prompt.push_str(&format!("System: {}\n\n", message.content));
-                }
-                "user" => {
-                    prompt.push_str(&format!("User: {}\n\n", message.content));
-                }
-                "assistant" => {
-                    prompt.push_str(&format!("Assistant: {}\n\n", message.content));
-                }
-                _ => {
-                    warn!("Unknown role: {}", message.role);
-                }
-            }
-        }
-
-        prompt.push_str("Assistant: ");
-        prompt
-    }
-
-    fn convert_anthropic_to_prompt(
-        &self,
-        messages: &[AnthropicMessage],
-        system: Option<&str>,
-    ) -> String {
-        let mut prompt = String::new();
-
-        if let Some(system) = system {
-            prompt.push_str(&format!("System: {system}\n\n"));
-        }
-
-        for message in messages {
-            match message.role.as_str() {
-                "user" => {
-                    prompt.push_str(&format!("User: {}\n\n", message.content));
-                }
-                "assistant" => {
-                    prompt.push_str(&format!("Assistant: {}\n\n", message.content));
-                }
-                _ => {
-                    warn!("Unknown role: {}", message.role);
-                }
-            }
-        }
-
-        prompt.push_str("Assistant: ");
-        prompt
-    }
-}
-
-#[async_trait]
-impl InferenceBackend for LocalInferenceService {
-    #[instrument(skip(self, request))]
-    async fn chat_completions(
-        &self,
-        request: ChatCompletionRequest,
-    ) -> Result<ChatCompletionResponse> {
-        let temperature = request
-            .temperature
-            .unwrap_or(self.config.default_temperature);
-        let max_tokens = request.max_tokens.unwrap_or(self.config.default_max_tokens);
-
-        debug!("Running inference with {} messages", request.messages.len());
-
-        // Use catgrad worker if available, otherwise fall back to mock
-        let response_text = if let Some(worker) = &self.catgrad_worker {
-            worker
-                .generate(
-                    request.model.clone(),
-                    request.messages.clone(),
-                    temperature,
-                    max_tokens as usize,
-                )
-                .await?
-        } else {
-            let prompt = self.convert_chat_to_prompt(&request.messages);
-            format!(
-                "This is a mock response from local model '{}'. Temperature: {}, Max tokens: {}. \
-                 No catgrad worker available. Prompt preview: '{}'",
-                request.model,
-                temperature,
-                max_tokens,
-                prompt.chars().take(100).collect::<String>()
-            )
-        };
-
-        let usage = Usage {
-            prompt_tokens: request
-                .messages
-                .iter()
-                .map(|m| m.content.split_whitespace().count())
-                .sum::<usize>() as u32,
-            completion_tokens: response_text.split_whitespace().count() as u32,
-            total_tokens: 0, // Will be calculated below
-        };
-        let usage = Usage {
-            prompt_tokens: usage.prompt_tokens,
-            completion_tokens: usage.completion_tokens,
-            total_tokens: usage.prompt_tokens + usage.completion_tokens,
-        };
-
-        Ok(ChatCompletionResponse {
-            id: format!("local-{}", uuid::Uuid::new_v4()),
-            object: "chat.completion".to_string(),
-            created: chrono::Utc::now().timestamp(),
-            model: request.model,
-            choices: vec![ChatChoice {
-                index: 0,
-                message: ChatMessage {
-                    role: "assistant".to_string(),
-                    content: response_text,
-                    name: None,
-                },
-                finish_reason: Some("stop".to_string()),
-            }],
-            usage: Some(usage),
-        })
-    }
-
-    async fn chat_completions_stream(
-        &self,
-        _request: ChatCompletionRequest,
-    ) -> Result<ChatCompletionStream> {
-        // TODO: Implement streaming when we integrate a real inference engine
-        Err(Error::Internal(
-            "Streaming not yet implemented for local inference".to_string(),
-        ))
-    }
-
-    async fn messages(&self, request: AnthropicMessageRequest) -> Result<AnthropicMessageResponse> {
-        let temperature = request
-            .temperature
-            .unwrap_or(self.config.default_temperature);
-        let max_tokens = request.max_tokens;
-
-        // Convert Anthropic messages to ChatMessage format
-        let mut chat_messages = Vec::new();
-
-        // Add system message if present
-        if let Some(system) = &request.system {
-            chat_messages.push(ChatMessage {
-                role: "system".to_string(),
-                content: system.clone(),
-                name: None,
-            });
-        }
-
-        // Add conversation messages
-        for msg in &request.messages {
-            chat_messages.push(ChatMessage {
-                role: msg.role.clone(),
-                content: msg.content.clone(),
-                name: None,
-            });
-        }
-
-        debug!(
-            "Running inference with {} messages (Anthropic format)",
-            chat_messages.len()
-        );
-
-        // Use catgrad worker if available
-        let response_text = if let Some(worker) = &self.catgrad_worker {
-            worker
-                .generate(
-                    request.model.clone(),
-                    chat_messages.clone(),
-                    temperature,
-                    max_tokens as usize,
-                )
-                .await?
-        } else {
-            let prompt =
-                self.convert_anthropic_to_prompt(&request.messages, request.system.as_deref());
-            format!(
-                "This is a mock response from local model '{}' using Anthropic format. \
-                 No catgrad worker available. Temperature: {}, Max tokens: {}. Prompt preview: '{}'",
-                request.model,
-                temperature,
-                max_tokens,
-                prompt.chars().take(100).collect::<String>()
-            )
-        };
-
-        let usage = AnthropicUsage {
-            input_tokens: chat_messages
-                .iter()
-                .map(|m| m.content.split_whitespace().count())
-                .sum::<usize>() as u32,
-            output_tokens: response_text.split_whitespace().count() as u32,
-        };
-
-        Ok(AnthropicMessageResponse {
-            id: format!("msg_{}", uuid::Uuid::new_v4()),
-            model: request.model,
-            role: "assistant".to_string(),
-            content: vec![AnthropicContent {
-                content_type: "text".to_string(),
-                text: response_text,
-            }],
-            stop_reason: Some("stop_sequence".to_string()),
-            stop_sequence: None,
-            usage,
-        })
-    }
-
-    async fn messages_stream(
-        &self,
-        _request: AnthropicMessageRequest,
-    ) -> Result<AnthropicMessageStream> {
-        todo!("Streaming not yet implemented for Anthropic messages");
-    }
-
-    async fn list_models(&self) -> Result<Vec<LocalModel>> {
-        // Return both specific popular models and supported architectures
-        let supported_models = vec![
-            // Broken
-            // GPT-2 models (GPT2LMHeadModel)
-            // LocalModel {
-            //     id: "openai-community/gpt2".to_string(),
-            //     name: "GPT-2 (124M)".to_string(),
-            //     provider: "local".to_string(),
-            //     path: None,
-            //     context_length: 1024,
-            //     supports_chat: true,
-            //     supports_completion: true,
-            // },
-            // Llama models (LlamaForCausalLM)
-            // LocalModel {
-            //     id: "meta-llama/Llama-3.2-1B-Instruct".to_string(),
-            //     name: "Llama 3.2 1B Instruct".to_string(),
-            //     provider: "local".to_string(),
-            //     path: None,
-            //     context_length: 128000,
-            //     supports_chat: true,
-            //     supports_completion: true,
-            // },
-            // LocalModel {
-            //     id: "meta-llama/Llama-3.2-3B-Instruct".to_string(),
-            //     name: "Llama 3.2 3B Instruct".to_string(),
-            //     provider: "local".to_string(),
-            //     path: None,
-            //     context_length: 128000,
-            //     supports_chat: true,
-            //     supports_completion: true,
-            // },
-            // 2025-07-10T23:29:27.954867Z  INFO gate_daemon::services::inference::catgrad: Loading model: TinyLlama/TinyLlama-1.1B-Chat-v1.0
-            // 2025-07-10T23:29:28.569271Z  INFO gate_daemon::services::inference::catgrad: Model TinyLlama/TinyLlama-1.1B-Chat-v1.0 loaded successfully
-            // thread '<unnamed>' panicked at /Users/grw/.cargo-gate-smb/git/checkouts/catgrad-8531093d3d852bf9/87f2f47/catgrad-llm/src/run.rs:98:10:
-            // template failed to render: Error { kind: InvalidOperation, detail: "tried to use + operator on unsupported types string and undefined", name: "chat", line: 4 }
-            // note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-            // LocalModel {
-            //     id: "TinyLlama/TinyLlama-1.1B-Chat-v1.0".to_string(),
-            //     name: "TinyLlama 1.1B Chat".to_string(),
-            //     provider: "local".to_string(),
-            //     path: None,
-            //     context_length: 2048,
-            //     supports_chat: true,
-            //     supports_completion: true,
-            // },
-            // Qwen3 models (Qwen3ForCausalLM)
-            LocalModel {
-                id: "Qwen/Qwen3-0.6B".to_string(),
-                name: "Qwen3 0.6B".to_string(),
-                provider: "local".to_string(),
-                path: None,
-                context_length: 32768,
-                supports_chat: true,
-                supports_completion: true,
-            },
-            LocalModel {
-                id: "huihui-ai/Huihui-Qwen3-14B-abliterated-v2".to_string(),
-                name: "Huihui Qwen3-14B Abliterated V2".to_string(),
-                provider: "local".to_string(),
-                path: None,
-                context_length: 8096,
-                supports_chat: true,
-                supports_completion: true,
-            },
-            // Gemma3 models (Gemma3ForCausalLM)
-            // LocalModel {
-            //     id: "google/gemma-3-1b-it".to_string(),
-            //     name: "Gemma 3 1B Instruct".to_string(),
-            //     provider: "local".to_string(),
-            //     path: None,
-            //     context_length: 8192,
-            //     supports_chat: true,
-            //     supports_completion: true,
-            // },
-            // Phi3 models (Phi3ForCausalLM)
-            // LocalModel {
-            //     id: "microsoft/Phi-3-mini-4k-instruct".to_string(),
-            //     name: "Phi-3 Mini 4K Instruct".to_string(),
-            //     provider: "local".to_string(),
-            //     path: None,
-            //     context_length: 4096,
-            //     supports_chat: true,
-            //     supports_completion: true,
-            // },
-            // segmentation fault
-            // LocalModel {
-            //     id: "c".to_string(),
-            //     name: "Phi-4 Mini Instruct".to_string(),
-            //     provider: "local".to_string(),
-            //     path: None,
-            //     context_length: 16384,
-            //     supports_chat: true,
-            //     supports_completion: true,
-            // },
-            // SmolLM3 models (SmolLM3ForCausalLM)
-            // LocalModel {
-            //     id: "HuggingFaceTB/SmolLM3-3B-Base".to_string(),
-            //     name: "SmolLM3 3B Base".to_string(),
-            //     provider: "local".to_string(),
-            //     path: None,
-            //     context_length: 8192,
-            //     supports_chat: true,
-            //     supports_completion: true,
-            // },
-            // // OLMo2 models (Olmo2ForCausalLM)
-            // LocalModel {
-            //     id: "allenai/OLMo-2-0425-1B-Instruct".to_string(),
-            //     name: "OLMo-2 1B Instruct".to_string(),
-            //     provider: "local".to_string(),
-            //     path: None,
-            //     context_length: 4096,
-            //     supports_chat: true,
-            //     supports_completion: true,
-            // },
-        ];
-
-        Ok(supported_models)
-    }
-
-    async fn get_model(&self, model_id: &str) -> Result<Option<LocalModel>> {
-        // TODO: fetch model details from hf/cache
-        Ok(Some(LocalModel {
-            id: model_id.to_string(),
-            name: model_id.to_string(),
-            provider: "local".to_string(),
-            path: None,
-            context_length: 4096,
-            supports_chat: true,
-            supports_completion: true,
-        }))
-    }
-
-    async fn health_check(&self) -> Result<bool> {
-        Ok(true)
-    }
-}
-
-pub struct LocalInferenceServiceBuilder {
-    config: LocalInferenceConfig,
-}
-
-impl LocalInferenceServiceBuilder {
-    pub fn new(config: LocalInferenceConfig) -> Self {
-        Self { config }
-    }
-
-    pub fn build(self) -> anyhow::Result<LocalInferenceService> {
-        LocalInferenceService::new(self.config).map_err(|e| anyhow::anyhow!("{}", e))
-    }
-}
-
-mod catgrad {
-    use super::*;
-    use catgrad_llm::{
-        run::{ModelLoader, ModelRunner, ModelTokenizer},
-        serve::{ChatTokenizer, LM, Loader, Message, Tokenizer},
-    };
-    use std::thread;
-
-    pub struct InferenceRequest {
-        pub model: String,
-        pub messages: Vec<ChatMessage>,
-        pub temperature: f32,
-        pub max_tokens: usize,
-        pub response_tx: oneshot::Sender<Result<String>>,
-    }
-
-    pub struct CatgradWorker {
-        request_tx: mpsc::Sender<InferenceRequest>,
-    }
-
-    impl CatgradWorker {
-        pub fn new() -> Result<Self> {
-            let (request_tx, mut request_rx) = mpsc::channel::<InferenceRequest>(32);
-
-            thread::spawn(move || {
-                let mut model_cache: HashMap<String, (ModelRunner, ModelTokenizer)> =
-                    HashMap::new();
-
-                while let Some(request) = request_rx.blocking_recv() {
-                    let response = match model_cache.get_mut(&request.model) {
-                        Some((runner, tokenizer)) => {
-                            // Use cached model
-                            generate_response(
-                                runner,
-                                tokenizer,
-                                request.messages,
-                                request.temperature,
-                                request.max_tokens,
-                            )
-                        }
-                        None => {
-                            // Load new model
-                            match load_model(&request.model) {
-                                Ok((mut runner, tokenizer)) => {
-                                    let response = generate_response(
-                                        &mut runner,
-                                        &tokenizer,
-                                        request.messages,
-                                        request.temperature,
-                                        request.max_tokens,
-                                    );
-                                    // Cache the model for future use
-                                    model_cache.insert(request.model.clone(), (runner, tokenizer));
-                                    response
-                                }
-                                Err(e) => Err(e),
-                            }
-                        }
-                    };
-                    let _ = request.response_tx.send(response);
-                }
-            });
-
-            Ok(CatgradWorker { request_tx })
-        }
-    }
-
-    fn load_model(model_name: &str) -> Result<(ModelRunner, ModelTokenizer)> {
-        info!("Loading model: {}", model_name);
-
-        let loader = ModelLoader::new(model_name, true)
-            .map_err(|e| Error::Internal(format!("Failed to create model loader: {e}")))?;
-
-        let runner = loader
-            .load_runner()
-            .map_err(|e| Error::Internal(format!("Failed to load model runner: {e}")))?;
-
-        let tokenizer = loader
-            .load_tokenizer()
-            .map_err(|e| Error::Internal(format!("Failed to load tokenizer: {e}")))?;
-
-        info!("Model {} loaded successfully", model_name);
-        Ok((runner, tokenizer))
-    }
-
-    impl CatgradWorker {
-        pub async fn generate(
-            &self,
-            model: String,
-            messages: Vec<ChatMessage>,
-            temperature: f32,
-            max_tokens: usize,
-        ) -> Result<String> {
-            let (response_tx, response_rx) = oneshot::channel();
-
-            let request = InferenceRequest {
-                model,
-                messages,
-                temperature,
-                max_tokens,
-                response_tx,
-            };
-
-            self.request_tx.send(request).await.map_err(|_| {
-                Error::Internal("Failed to send request to inference worker".to_string())
-            })?;
-
-            response_rx.await.map_err(|_| {
-                Error::Internal("Failed to receive response from inference worker".to_string())
-            })?
-        }
-    }
-
-    fn generate_response(
-        runner: &mut ModelRunner,
-        tokenizer: &ModelTokenizer,
-        messages: Vec<ChatMessage>,
-        _temperature: f32, // TODO: Implement temperature sampling
-        max_tokens: usize,
-    ) -> Result<String> {
-        // Convert ChatMessage to catgrad Message format
-        let catgrad_messages: Vec<Message> = messages
-            .iter()
-            .map(|msg| Message {
-                role: msg.role.clone(),
-                content: msg.content.clone(),
-            })
-            .collect();
-
-        // Encode messages to tokens
-        let context = tokenizer
-            .encode_messages(catgrad_messages)
-            .map_err(|e| Error::Internal(format!("Failed to encode messages: {e}")))?;
-
-        // Generate tokens
-        let mut generated_tokens = Vec::new();
-        let mut token_count = 0;
-
-        for token in runner.complete(context) {
-            generated_tokens.push(token);
-            token_count += 1;
-
-            if token_count >= max_tokens {
-                break;
-            }
-        }
-
-        // Decode tokens back to text
-        let response = tokenizer
-            .decode(generated_tokens)
-            .map_err(|e| Error::Internal(format!("Failed to decode tokens: {e}")))?;
-
-        Ok(response)
-    }
-}
diff --git a/crates/daemon/src/services/key_capture.rs b/crates/daemon/src/services/key_capture.rs
deleted file mode 100644
index 001e6fd1..00000000
--- a/crates/daemon/src/services/key_capture.rs
+++ /dev/null
@@ -1,119 +0,0 @@
-use crate::Settings;
-use crate::daemon::Daemon;
-use gate_core::Result;
-use gate_core::router::index::SinkIndex;
-use gate_core::router::middleware::KeyCaptureRegistrar;
-use gate_core::router::registry::SinkRegistry;
-use std::collections::HashSet;
-use std::sync::Arc;
-use tokio::sync::Mutex;
-
-pub struct DaemonKeyRegistrar {
-    daemon: Daemon,
-    sink_registry: Arc<SinkRegistry>,
-    sink_index: Arc<SinkIndex>,
-    created: Mutex<HashSet<String>>, // prevent duplicate work in-process
-}
-
-impl DaemonKeyRegistrar {
-    pub fn new(
-        daemon: Daemon,
-        sink_registry: Arc<SinkRegistry>,
-        sink_index: Arc<SinkIndex>,
-    ) -> Self {
-        Self {
-            daemon,
-            sink_registry,
-            sink_index,
-            created: Mutex::new(HashSet::new()),
-        }
-    }
-
-    async fn settings_has_anthropic_key(settings: &Settings, key: &str) -> bool {
-        settings.providers.iter().any(|p| {
-            matches!(p.provider, crate::config::ProviderType::Anthropic)
-                && p.api_key.as_deref() == Some(key)
-        })
-    }
-}
-
-#[async_trait::async_trait]
-impl KeyCaptureRegistrar for DaemonKeyRegistrar {
-    async fn register_anthropic_key(&self, key: &str) -> Result<()> {
-        // Dedup per-process
-        {
-            let mut guard = self.created.lock().await;
-            if !guard.insert(key.to_string()) {
-                return Ok(());
-            }
-        }
-
-        // Check current settings
-        let settings = match self.daemon.get_settings().await {
-            Ok(s) => s,
-            Err(_) => return Ok(()),
-        };
-        if Self::settings_has_anthropic_key(&settings, key).await {
-            return Ok(());
-        }
-
-        // Build a new provider config entry
-        let mut new_settings = settings.clone();
-        // Choose a unique name
-        let base_name = "anthropic";
-        let mut name = base_name.to_string();
-        let mut i = 1u32;
-        while new_settings.providers.iter().any(|p| p.name == name) {
-            name = format!("{base_name}-{i}");
-            i += 1;
-        }
-
-        let provider_cfg = crate::config::ProviderConfig {
-            name: name.clone(),
-            provider: crate::config::ProviderType::Anthropic,
-            base_url: "https://api.anthropic.com".to_string(),
-            api_key: Some(key.to_string()),
-            timeout_seconds: 600,
-            models: vec![],
-        };
-        new_settings.providers.push(provider_cfg);
-
-        // Persist settings with system identity
-        let _ = self
-            .daemon
-            .system_identity()
-            .update_config(new_settings)
-            .await;
-
-        // Register sink immediately, and drop fallback if present
-        let sink = match gate_http::sinks::anthropic::create_sink(
-            gate_http::sinks::anthropic::AnthropicConfig {
-                api_key: Some(key.to_string()),
-                base_url: None,
-                timeout_seconds: None,
-                sink_id: Some(format!("provider://anthropic/{name}")),
-            },
-        )
-        .await
-        {
-            Ok(s) => Arc::new(s),
-            Err(_) => return Ok(()), // Don't fail request path on registration issues
-        };
-
-        // Remove fallback if present to avoid routing ambiguity
-        self.sink_registry
-            .remove("provider://anthropic/fallback")
-            .await;
-        self.sink_registry
-            .register(format!("provider://anthropic/{name}"), sink)
-            .await;
-
-        // Refresh index
-        let _ = self
-            .sink_index
-            .refresh_from_registry(&self.sink_registry)
-            .await;
-
-        Ok(())
-    }
-}
diff --git a/crates/daemon/src/services/mod.rs b/crates/daemon/src/services/mod.rs
deleted file mode 100644
index 929aa992..00000000
--- a/crates/daemon/src/services/mod.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-pub mod auth;
-pub mod inference;
-pub mod key_capture;
-pub mod monitoring;
-pub mod p2p;
-pub mod tls;
-pub mod tlsforward;
-pub mod webauthn;
-
-pub use auth::AuthService;
-pub use inference::{LocalInferenceService, LocalInferenceServiceBuilder};
-pub use tlsforward::{TlsForwardService, TlsForwardState};
-pub use webauthn::WebAuthnService;
diff --git a/crates/daemon/src/services/monitoring.rs b/crates/daemon/src/services/monitoring.rs
deleted file mode 100644
index 197b59aa..00000000
--- a/crates/daemon/src/services/monitoring.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-use gate_core::StateBackend;
-use std::sync::Arc;
-use tokio::task::JoinHandle;
-
-use crate::services::{TlsForwardService, TlsForwardState, WebAuthnService};
-
-/// Manages all monitoring tasks
-pub struct MonitoringService {
-    tasks: Vec<JoinHandle<()>>,
-}
-
-impl MonitoringService {
-    /// Start all monitoring tasks
-    pub fn new() -> Self {
-        Self { tasks: Vec::new() }
-    }
-
-    /// Start database pool metrics collection
-    pub fn monitor_database_pool(&mut self, _state_backend: Arc<dyn StateBackend>) {
-        // TODO: Add pool_metrics to StateBackend trait or use a different approach
-        // For now, skip database pool monitoring in the refactored version
-        debug!("Database pool monitoring not implemented for trait objects");
-    }
-
-    /// Monitor TLS forward state for WebAuthn updates
-    pub fn monitor_webauthn_tlsforward(
-        &mut self,
-        service: Arc<TlsForwardService>,
-        webauthn_service: Arc<WebAuthnService>,
-    ) {
-        let mut state_rx = service.subscribe();
-        let mut last_domain: Option<String> = None;
-
-        let handle = tokio::spawn(async move {
-            while state_rx.changed().await.is_ok() {
-                let state = state_rx.borrow().clone();
-                if let TlsForwardState::Connected {
-                    assigned_domain, ..
-                } = state
-                {
-                    // Check if domain changed
-                    if last_domain.as_ref() != Some(&assigned_domain) {
-                        // Build the HTTPS origin URL for the assigned domain
-                        let tlsforward_origin = format!("https://{assigned_domain}");
-
-                        info!(
-                            "TLS forward connected with domain: {}, updating WebAuthn allowed origins",
-                            assigned_domain
-                        );
-
-                        // Add the TLS forward origin to WebAuthn allowed origins
-                        if let Err(e) = webauthn_service
-                            .add_allowed_origin(tlsforward_origin.clone())
-                            .await
-                        {
-                            error!("Failed to add TLS forward origin to WebAuthn: {}", e);
-                        } else {
-                            debug!(
-                                "Successfully added {} to WebAuthn allowed origins",
-                                tlsforward_origin
-                            );
-                            last_domain = Some(assigned_domain);
-                        }
-                    }
-                }
-            }
-        });
-
-        self.tasks.push(handle);
-    }
-
-    /// Graceful shutdown of all monitoring tasks
-    pub async fn shutdown(self) {
-        info!("Shutting down monitoring tasks");
-        for task in self.tasks {
-            task.abort();
-        }
-    }
-}
-
-impl Default for MonitoringService {
-    fn default() -> Self {
-        Self::new()
-    }
-}
diff --git a/crates/daemon/src/services/p2p.rs b/crates/daemon/src/services/p2p.rs
deleted file mode 100644
index 245f5f62..00000000
--- a/crates/daemon/src/services/p2p.rs
+++ /dev/null
@@ -1,220 +0,0 @@
-use anyhow::Result;
-use gate_http::server::HttpServer;
-use gate_p2p::{Endpoint, NodeAddr, Router, SecretKey, discovery::static_provider::StaticProvider};
-use gate_tlsforward::{TLS_FORWARD_ALPN, TlsForwardHandler};
-use std::path::Path;
-use std::sync::Arc;
-
-use crate::{
-    config::TlsForwardConfig, services::TlsForwardService, tls_reload::ReloadableTlsAcceptor,
-};
-
-/// P2P configuration
-pub struct P2PConfig {
-    pub secret_key_path: std::path::PathBuf,
-    pub enable_discovery: bool,
-    pub tlsforward_addresses: Vec<String>,
-}
-
-/// Manages P2P endpoint and routing
-#[derive(Clone)]
-pub struct P2PManager {
-    endpoint: Arc<Endpoint>,
-    router: Option<Router>,
-}
-
-impl P2PManager {
-    /// Create a new P2P manager
-    pub async fn new(config: P2PConfig) -> Result<Self> {
-        // Load or create P2P secret key
-        let secret_key = load_or_create_p2p_secret_key(&config.secret_key_path).await?;
-
-        // Create P2P endpoint
-        let endpoint = create_p2p_endpoint(
-            secret_key,
-            config.enable_discovery,
-            &config.tlsforward_addresses,
-        )
-        .await?;
-
-        info!("P2P endpoint created with node ID: {}", endpoint.node_id());
-
-        Ok(Self {
-            endpoint,
-            router: None,
-        })
-    }
-
-    /// Get the P2P endpoint
-    pub fn endpoint(&self) -> Arc<Endpoint> {
-        self.endpoint.clone()
-    }
-
-    /// Setup TLS forward handler for accepting incoming connections
-    pub fn setup_tls_forward_handler(
-        &mut self,
-        tls_acceptor: Arc<ReloadableTlsAcceptor>,
-        http_server: Arc<HttpServer>,
-        max_connections: usize,
-        connection_timeout_secs: u64,
-    ) -> Result<()> {
-        // Create TLS forward handler
-        let tls_handler = TlsForwardHandler::new(
-            tls_acceptor.as_ref().clone(),
-            http_server,
-            max_connections,
-            connection_timeout_secs,
-        );
-
-        // Create router and register the TLS forward handler
-        let router = Router::builder(self.endpoint.as_ref().clone())
-            .accept(TLS_FORWARD_ALPN, tls_handler)
-            .spawn();
-
-        debug!("Registered TLS forward handler on P2P endpoint");
-        self.router = Some(router);
-
-        Ok(())
-    }
-
-    /// Start TLS forward client service
-    pub async fn start_tlsforward_service(
-        &self,
-        config: TlsForwardConfig,
-    ) -> Result<Arc<TlsForwardService>> {
-        debug!("Initializing TLS forward client service");
-
-        let service = TlsForwardService::builder(config, self.endpoint.clone())
-            .build()
-            .await?;
-
-        Ok(service)
-    }
-
-    /// Wait for TLS forward service to connect and return node ID
-    pub async fn wait_for_tlsforward_connection(
-        &self,
-        service: &Arc<TlsForwardService>,
-        timeout_secs: u64,
-    ) -> Option<gate_p2p::NodeId> {
-        let mut retry_count = 0;
-        loop {
-            if let Some(node_id) = service.tlsforward_node_id().await {
-                return Some(node_id);
-            }
-            retry_count += 1;
-            if retry_count > timeout_secs {
-                warn!(
-                    "TLS forward server not connected after {} seconds",
-                    timeout_secs
-                );
-                return None;
-            }
-            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-        }
-    }
-}
-
-/// Load or create P2P secret key
-async fn load_or_create_p2p_secret_key(path: &Path) -> Result<SecretKey> {
-    use tokio::fs;
-
-    if path.exists() {
-        // Try to load existing key
-        match fs::read_to_string(&path).await {
-            Ok(contents) => {
-                let hex_key = contents.trim();
-                match hex::decode(hex_key) {
-                    Ok(key_bytes) if key_bytes.len() == 32 => {
-                        let mut key_array = [0u8; 32];
-                        key_array.copy_from_slice(&key_bytes);
-                        let secret_key = SecretKey::from_bytes(&key_array);
-                        info!("Loaded P2P secret key from {}", path.display());
-                        Ok(secret_key)
-                    }
-                    _ => {
-                        warn!(
-                            "Invalid P2P secret key format in {}, generating new key",
-                            path.display()
-                        );
-                        create_and_save_p2p_key(path).await
-                    }
-                }
-            }
-            Err(e) => {
-                warn!(
-                    "Failed to read P2P secret key from {}: {}, generating new key",
-                    path.display(),
-                    e
-                );
-                create_and_save_p2p_key(path).await
-            }
-        }
-    } else {
-        info!(
-            "P2P secret key file not found at {}, generating new key",
-            path.display()
-        );
-        create_and_save_p2p_key(path).await
-    }
-}
-
-/// Create and save a new P2P secret key
-async fn create_and_save_p2p_key(path: &Path) -> Result<SecretKey> {
-    use rand::rngs::OsRng;
-    use tokio::fs;
-
-    let secret_key = SecretKey::generate(OsRng);
-    let key_bytes = secret_key.to_bytes();
-    let hex_key = hex::encode(key_bytes);
-
-    // Ensure parent directory exists
-    if let Some(parent) = path.parent() {
-        fs::create_dir_all(parent).await?;
-    }
-
-    fs::write(path, hex_key).await?;
-    info!("Created and saved new P2P secret key to {}", path.display());
-    Ok(secret_key)
-}
-
-/// Create P2P endpoint with optional static discovery
-async fn create_p2p_endpoint(
-    secret_key: SecretKey,
-    enable_discovery: bool,
-    tlsforward_servers: &[String],
-) -> Result<Arc<Endpoint>> {
-    let mut endpoint_builder = Endpoint::builder().secret_key(secret_key);
-
-    if enable_discovery {
-        endpoint_builder = endpoint_builder.discovery_n0();
-    }
-
-    // Add static discovery for TLS forward servers if configured
-    if !tlsforward_servers.is_empty() {
-        let static_provider = StaticProvider::new();
-
-        for server in tlsforward_servers {
-            // Parse TLS forward server address
-            if let Some((node_id_str, addr_str)) = server.split_once('@')
-                && let Ok(node_id) = node_id_str.parse::<gate_p2p::NodeId>()
-                && let Ok(socket_addr) = addr_str.parse::<std::net::SocketAddr>()
-            {
-                let node_addr = NodeAddr::from_parts(
-                    node_id,
-                    None, // No relay URL
-                    vec![socket_addr],
-                );
-                static_provider.add_node_info(node_addr);
-                info!(
-                    "Added static node discovery for TLS forward server: {} at {}",
-                    node_id, socket_addr
-                );
-            }
-        }
-
-        endpoint_builder = endpoint_builder.add_discovery(static_provider);
-    }
-
-    Ok(Arc::new(endpoint_builder.bind().await?))
-}
diff --git a/crates/daemon/src/services/tls.rs b/crates/daemon/src/services/tls.rs
deleted file mode 100644
index 03f2c854..00000000
--- a/crates/daemon/src/services/tls.rs
+++ /dev/null
@@ -1,161 +0,0 @@
-use anyhow::Result;
-use gate_tlsforward::{CertificateManager, TlsForwardClient};
-use std::path::Path;
-use std::sync::Arc;
-use tokio::sync::Mutex;
-
-use crate::{services::TlsForwardService, tls_reload::ReloadableTlsAcceptor};
-
-/// Manages TLS certificates and acceptors
-#[derive(Clone)]
-pub struct TlsManager {
-    certificate_manager: Arc<Mutex<CertificateManager>>,
-    reloadable_acceptor: Arc<ReloadableTlsAcceptor>,
-}
-
-impl TlsManager {
-    /// Create a new TLS manager
-    pub async fn new(data_dir: &Path, initial_domains: Vec<String>) -> Result<Self> {
-        // Create certificate manager
-        let cert_manager = Arc::new(Mutex::new(CertificateManager::new(data_dir.to_path_buf())));
-
-        // Get domains for certificate
-        let mut domains = initial_domains;
-
-        // Only add localhost if no other domains are configured
-        if domains.is_empty() {
-            domains.push("localhost".to_string());
-        }
-
-        // Get or create TLS acceptor
-        let acceptor = cert_manager
-            .lock()
-            .await
-            .get_or_create_tls_acceptor(&domains)
-            .await?;
-        let reloadable_acceptor = Arc::new(ReloadableTlsAcceptor::new(acceptor));
-
-        Ok(Self {
-            certificate_manager: cert_manager,
-            reloadable_acceptor,
-        })
-    }
-
-    /// Get the reloadable TLS acceptor
-    pub fn acceptor(&self) -> Arc<ReloadableTlsAcceptor> {
-        self.reloadable_acceptor.clone()
-    }
-
-    /// Set TLS forward client for ACME challenges
-    pub async fn set_tls_forward_client(
-        &self,
-        endpoint: Arc<gate_p2p::Endpoint>,
-        node_id: gate_p2p::NodeId,
-    ) {
-        let client = TlsForwardClient::new(endpoint, node_id);
-        self.certificate_manager
-            .lock()
-            .await
-            .set_tls_forward_client(client);
-        debug!("Certificate manager configured with TLS forward client");
-    }
-
-    /// Request Let's Encrypt certificates
-    pub async fn request_certificates(&self, domains: Vec<String>, email: &str) -> Result<()> {
-        if domains.is_empty() {
-            return Ok(());
-        }
-
-        info!("Requesting certificates for configured domains");
-        for domain in &domains {
-            info!("Checking certificate for domain: https://{}", domain);
-
-            let cert_mgr = self.certificate_manager.lock().await;
-            if !cert_mgr.has_certificate(domain).await {
-                info!("Requesting new certificate for https://{}", domain);
-                match cert_mgr.request_certificate(domain, email).await {
-                    Ok(()) => {
-                        info!("Successfully obtained certificate for {}", domain);
-                        // Reload TLS acceptor with new certificates
-                        if let Ok(new_acceptor) =
-                            cert_mgr.get_or_create_tls_acceptor(&domains).await
-                        {
-                            self.reloadable_acceptor.reload(new_acceptor).await;
-                            info!(
-                                "Reloaded TLS acceptor with new certificates for domains: {:?}",
-                                domains
-                            );
-                        }
-                    }
-                    Err(e) => {
-                        error!("Failed to obtain certificate for https://{}: {}", domain, e)
-                    }
-                }
-            } else {
-                info!("Certificate already exists for https://{}", domain);
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Monitor TLS forward service for certificate updates
-    pub async fn monitor_tlsforward_certificates(
-        &self,
-        service: Arc<TlsForwardService>,
-        letsencrypt_domains: Vec<String>,
-    ) {
-        let cert_manager = self.certificate_manager.clone();
-        let acceptor = self.reloadable_acceptor.clone();
-
-        let mut state_rx = service.subscribe();
-        let mut last_domain: Option<String> = None;
-
-        tokio::spawn(async move {
-            while state_rx.changed().await.is_ok() {
-                let state = state_rx.borrow().clone();
-                if let crate::services::TlsForwardState::Connected {
-                    assigned_domain, ..
-                } = state
-                    && last_domain.as_ref() != Some(&assigned_domain)
-                {
-                    info!("TLS forward connected with new domain: {}", assigned_domain);
-                    info!(
-                        "TLS forward domain {} detected. Manual config update required for Let's Encrypt.",
-                        assigned_domain
-                    );
-
-                    // Check if we have a certificate for this domain
-                    let cert_mgr = cert_manager.lock().await;
-                    if cert_mgr.has_certificate(&assigned_domain).await {
-                        info!(
-                            "Found existing certificate for TLS forward domain: {}",
-                            assigned_domain
-                        );
-
-                        // Reload TLS acceptor with TLS forward domain
-                        let mut domains = vec![assigned_domain.clone()];
-                        domains.extend(letsencrypt_domains.clone());
-
-                        if let Ok(new_acceptor) =
-                            cert_mgr.get_or_create_tls_acceptor(&domains).await
-                        {
-                            acceptor.reload(new_acceptor).await;
-                            info!(
-                                "Reloaded TLS acceptor with TLS forward domain: {}",
-                                assigned_domain
-                            );
-                            last_domain = Some(assigned_domain);
-                        }
-                    } else {
-                        info!(
-                            "No certificate found for TLS forward domain: {}, will be requested later",
-                            assigned_domain
-                        );
-                        last_domain = Some(assigned_domain);
-                    }
-                }
-            }
-        });
-    }
-}
diff --git a/crates/daemon/src/services/tlsforward.rs b/crates/daemon/src/services/tlsforward.rs
deleted file mode 100644
index 88547169..00000000
--- a/crates/daemon/src/services/tlsforward.rs
+++ /dev/null
@@ -1,326 +0,0 @@
-//! TLS forward service for managing P2P TLS forwarding connections
-
-use crate::config::TlsForwardConfig;
-use crate::tracing::Instrument;
-use anyhow::{Context, Result};
-use gate_p2p::Endpoint;
-use gate_tlsforward::TlsForwardClient;
-use iroh::NodeId;
-use std::sync::Arc;
-use std::time::Duration;
-use tokio::sync::{RwLock, watch};
-use tokio::time;
-
-/// TLS forward service state
-#[derive(Debug, Clone, PartialEq)]
-pub enum TlsForwardState {
-    /// Not connected to any relay
-    Disconnected,
-    /// Connecting to TLS forward server
-    Connecting,
-    /// Connected and registered with relay
-    Connected {
-        tlsforward_node: NodeId,
-        assigned_domain: String,
-    },
-    /// Connection error
-    Error(String),
-}
-
-/// Internal state for active TLS forward connection
-struct ActiveTlsForwardConnection {
-    tls_forward_client: TlsForwardClient,
-    node_id: NodeId,
-}
-
-/// Builder for configuring TlsForwardService
-pub struct TlsForwardServiceBuilder {
-    config: TlsForwardConfig,
-    endpoint: Arc<Endpoint>,
-}
-
-impl TlsForwardServiceBuilder {
-    /// Create a new builder with the given config and TLS handler
-    pub fn new(config: TlsForwardConfig, endpoint: Arc<Endpoint>) -> Self {
-        Self { config, endpoint }
-    }
-
-    /// Build and start the TLS forward service
-    pub async fn build(self) -> Result<Arc<TlsForwardService>> {
-        debug!("TlsForward config: {:?}", self.config);
-
-        if !self.config.enabled {
-            warn!(
-                "Tried creating TlsForwardServiceBuilder but TLS forward service is disabled: {:?}",
-                self.config
-            );
-            return Err(anyhow::anyhow!("TLS forward service is disabled"));
-        }
-
-        // Create channels
-        let (state_tx, state_rx) = watch::channel(TlsForwardState::Disconnected);
-        let (shutdown_tx, _) = watch::channel(false);
-
-        let service = Arc::new(TlsForwardService {
-            config: self.config,
-            endpoint: self.endpoint.clone(),
-            active_connection: Arc::new(RwLock::new(None)),
-            state_tx,
-            state_rx,
-            shutdown_tx,
-        });
-
-        // Start connection loop
-        let service_clone = service.clone();
-        tokio::spawn(async move {
-            service_clone.connection_loop().await;
-        });
-
-        Ok(service)
-    }
-}
-
-/// TLS forward service for managing connections to TLS forward servers
-pub struct TlsForwardService {
-    config: TlsForwardConfig,
-    endpoint: Arc<Endpoint>,
-    active_connection: Arc<RwLock<Option<ActiveTlsForwardConnection>>>,
-    state_tx: watch::Sender<TlsForwardState>,
-    state_rx: watch::Receiver<TlsForwardState>,
-    shutdown_tx: watch::Sender<bool>,
-}
-
-impl TlsForwardService {
-    /// Create a new builder for the TLS forward service
-    pub fn builder(config: TlsForwardConfig, endpoint: Arc<Endpoint>) -> TlsForwardServiceBuilder {
-        TlsForwardServiceBuilder::new(config, endpoint)
-    }
-
-    /// Get current relay state
-    pub fn state(&self) -> TlsForwardState {
-        self.state_rx.borrow().clone()
-    }
-
-    /// Subscribe to state changes
-    pub fn subscribe(&self) -> watch::Receiver<TlsForwardState> {
-        self.state_rx.clone()
-    }
-
-    /// Get the endpoint reference
-    pub fn endpoint(&self) -> &Endpoint {
-        &self.endpoint
-    }
-
-    /// Get the connected relay node ID
-    pub async fn tlsforward_node_id(&self) -> Option<iroh::NodeId> {
-        let connection = self.active_connection.read().await;
-        connection.as_ref().map(|c| c.node_id)
-    }
-
-    /// Main connection loop
-    async fn connection_loop(&self) {
-        let mut shutdown_rx = self.shutdown_tx.subscribe();
-        let mut reconnect_attempts = 0;
-
-        loop {
-            tokio::select! {
-                _ = shutdown_rx.changed() => {
-                    if *shutdown_rx.borrow() {
-                        info!("TLS forward service shutting down");
-                        break;
-                    }
-                }
-                result = self.connect_to_relay(&mut reconnect_attempts) => {
-                    if let Err(e) = result {
-                        error!("Failed to connect to relay: {}", e);
-                    }
-
-                    if !self.config.auto_reconnect {
-                        break;
-                    }
-
-                    // Wait before reconnecting
-                    let backoff = Duration::from_secs(
-                        self.config.reconnect_backoff * (reconnect_attempts as u64 + 1)
-                    );
-                    info!("Waiting {}s before reconnecting (attempt {})", backoff.as_secs(), reconnect_attempts + 1);
-                    time::sleep(backoff).await;
-                }
-            }
-        }
-    }
-
-    /// Connect to relay server
-    async fn connect_to_relay(&self, reconnect_attempts: &mut u32) -> Result<()> {
-        debug!("Attempting to connect to relay...");
-
-        // Update state
-        self.state_tx.send(TlsForwardState::Connecting)?;
-
-        debug!("Endpoint ready, parsing relay addresses...");
-
-        // Try each relay address
-        for tlsforward_addr_str in &self.config.tlsforward_addresses {
-            debug!("Trying TLS forward address: {}", tlsforward_addr_str);
-
-            // Parse node ID from address string
-            // We now only care about the node ID part, as addresses are handled by discovery
-            let node_id =
-                if let Some((node_id_str, _addr_str)) = tlsforward_addr_str.split_once('@') {
-                    // Format: node_id@address:port - extract just the node ID
-                    node_id_str
-                        .parse::<iroh::NodeId>()
-                        .map_err(|e| anyhow::anyhow!("Invalid node ID '{}': {}", node_id_str, e))?
-                } else {
-                    // Just a node ID
-                    tlsforward_addr_str.parse::<iroh::NodeId>().map_err(|e| {
-                        anyhow::anyhow!("Invalid node ID '{}': {}", tlsforward_addr_str, e)
-                    })?
-                };
-
-            debug!("Connecting to TLS forward server with node ID: {}", node_id);
-
-            match self.connect_to_tlsforward_addr(node_id).await {
-                Ok(assigned_domain) => {
-                    info!(
-                        "Connected to tlsforward. Assigned domain: {}",
-                        assigned_domain
-                    );
-                    self.state_tx.send(TlsForwardState::Connected {
-                        tlsforward_node: node_id,
-                        assigned_domain: assigned_domain.clone(),
-                    })?;
-
-                    *reconnect_attempts = 0;
-
-                    // Start heartbeat loop
-                    self.heartbeat_loop().await;
-
-                    return Ok(());
-                }
-                Err(e) => {
-                    error!("Failed to connect to TLS forward server {}: {}", node_id, e);
-                    continue;
-                }
-            }
-        }
-
-        // All relays failed
-        *reconnect_attempts += 1;
-        let error_msg = "Failed to connect to any TLS forward server".to_string();
-        self.state_tx
-            .send(TlsForwardState::Error(error_msg.clone()))?;
-
-        if *reconnect_attempts >= self.config.max_reconnect_attempts {
-            error!("Maximum reconnection attempts reached");
-            return Err(anyhow::anyhow!("Maximum reconnection attempts reached"));
-        }
-
-        Err(anyhow::anyhow!(error_msg))
-    }
-
-    /// Connect to a specific TLS forward address
-    async fn connect_to_tlsforward_addr(&self, node_id: NodeId) -> Result<String> {
-        let span = tracing::info_span!(
-            "tlsforward.connect",
-            tlsforward_node = %node_id,
-        );
-
-        async move {
-            // Create TLS forward client
-            let tls_forward_client = TlsForwardClient::new(self.endpoint.clone(), node_id);
-
-            // Register with TLS forward server
-            let (assigned_domain, _tlsforward_info) = tls_forward_client
-                .register()
-                .await
-                .context("Failed to register with TLS forward server")?;
-
-            // Record assigned domain in span
-            tracing::Span::current().record("assigned_domain", &assigned_domain);
-
-            // Store active connection
-            let active = ActiveTlsForwardConnection {
-                tls_forward_client,
-                node_id,
-            };
-            *self.active_connection.write().await = Some(active);
-
-            Ok(assigned_domain)
-        }
-        .instrument(span)
-        .await
-    }
-
-    /// Heartbeat loop to maintain connection
-    async fn heartbeat_loop(&self) {
-        let mut shutdown_rx = self.shutdown_tx.subscribe();
-        let heartbeat_interval = Duration::from_secs(self.config.heartbeat_interval);
-        let mut interval = time::interval(heartbeat_interval);
-
-        loop {
-            tokio::select! {
-                _ = shutdown_rx.changed() => {
-                    if *shutdown_rx.borrow() {
-                        break;
-                    }
-                }
-                _ = interval.tick() => {
-                    if let Err(e) = self.send_heartbeat().await {
-                        error!("Heartbeat failed: {}", e);
-                        self.state_tx.send(TlsForwardState::Disconnected).ok();
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
-    /// Send heartbeat to TLS forward server
-    async fn send_heartbeat(&self) -> Result<()> {
-        let connection = self.active_connection.read().await;
-        let active = connection
-            .as_ref()
-            .context("No active TLS forward connection")?;
-
-        // Send ping with timeout
-        tokio::time::timeout(Duration::from_secs(10), active.tls_forward_client.ping())
-            .await
-            .map_err(|_| anyhow::anyhow!("Heartbeat timeout"))?
-            .context("Heartbeat ping failed")?;
-
-        debug!("Heartbeat sent successfully");
-        Ok(())
-    }
-
-    /// Disconnect from TLS forward server
-    pub async fn disconnect(&self) -> Result<()> {
-        info!("Disconnecting from TLS forward server");
-
-        // Unregister from TLS forward server
-        if let Some(active) = self.active_connection.write().await.take()
-            && let Err(e) = active.tls_forward_client.unregister().await
-        {
-            warn!("Failed to unregister from TLS forward server: {}", e);
-        }
-
-        // Update state
-        self.state_tx.send(TlsForwardState::Disconnected)?;
-
-        Ok(())
-    }
-
-    /// Shutdown the service
-    pub async fn shutdown(&self) {
-        info!("Shutting down TLS forward service");
-        self.shutdown_tx.send(true).ok();
-        self.disconnect().await.ok();
-    }
-}
-
-impl Drop for TlsForwardService {
-    fn drop(&mut self) {
-        // Trigger shutdown when service is dropped
-        self.shutdown_tx.send(true).ok();
-    }
-}
diff --git a/crates/daemon/src/services/webauthn.rs b/crates/daemon/src/services/webauthn.rs
deleted file mode 100644
index 3f291908..00000000
--- a/crates/daemon/src/services/webauthn.rs
+++ /dev/null
@@ -1,247 +0,0 @@
-//! WebAuthn service for managing WebAuthn operations
-
-use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
-use chrono::Utc;
-use gate_http::error::HttpError;
-use gate_http::middleware::webauthn::WebAuthnSession;
-use gate_http::middleware::{WebAuthnConfig, WebAuthnState};
-use gate_sqlx::SqliteWebAuthnBackend;
-use std::sync::Arc;
-use uuid::Uuid;
-use webauthn_rs::prelude::*;
-
-/// WebAuthn service for authentication operations
-pub struct WebAuthnService {
-    state: Arc<WebAuthnState>,
-    backend: Arc<SqliteWebAuthnBackend>,
-}
-
-impl WebAuthnService {
-    /// Create a new WebAuthn service
-    pub fn new(
-        config: WebAuthnConfig,
-        backend: Arc<SqliteWebAuthnBackend>,
-    ) -> Result<Self, HttpError> {
-        let state = WebAuthnState::new(config).map_err(|e| {
-            HttpError::InternalServerError(format!("Failed to initialize WebAuthn: {e}"))
-        })?;
-
-        Ok(Self {
-            state: Arc::new(state),
-            backend,
-        })
-    }
-
-    /// Get the WebAuthn state
-    pub fn state(&self) -> Arc<WebAuthnState> {
-        self.state.clone()
-    }
-
-    /// Start registration for a new user
-    pub async fn start_registration(
-        &self,
-        user_name: String,
-    ) -> Result<(serde_json::Value, String), HttpError> {
-        let user_id = Uuid::new_v4();
-
-        // Start passkey registration
-        let (ccr, reg_state) = self
-            .state
-            .webauthn()
-            .read()
-            .await
-            .start_passkey_registration(user_id, &user_name, &user_name, None)
-            .map_err(|e| {
-                HttpError::InternalServerError(format!("Failed to start registration: {e}"))
-            })?;
-
-        // Generate session ID
-        let session_id = WebAuthnState::generate_session_id();
-
-        // Store session
-        let session = WebAuthnSession {
-            user_name: Some(user_name),
-            registration_state: Some(reg_state),
-            authentication_state: None,
-            created_at: Utc::now(),
-        };
-        self.state.store_session(session_id.clone(), session).await;
-
-        // Convert to JSON
-        let challenge_json = serde_json::to_value(ccr).map_err(|e| {
-            HttpError::InternalServerError(format!("Failed to serialize challenge: {e}"))
-        })?;
-
-        Ok((challenge_json, session_id))
-    }
-
-    /// Complete registration with credential
-    pub async fn complete_registration(
-        &self,
-        session_id: String,
-        credential_json: serde_json::Value,
-    ) -> Result<(Passkey, String, String), HttpError> {
-        // Get session
-        let session = self
-            .state
-            .get_session(&session_id)
-            .await
-            .ok_or_else(|| HttpError::BadRequest("Invalid session".to_string()))?;
-
-        let reg_state = session
-            .registration_state
-            .ok_or_else(|| HttpError::BadRequest("Invalid session state".to_string()))?;
-
-        let user_name = session
-            .user_name
-            .ok_or_else(|| HttpError::BadRequest("Missing user name".to_string()))?;
-
-        // Deserialize the credential
-        let credential: RegisterPublicKeyCredential = serde_json::from_value(credential_json)
-            .map_err(|e| HttpError::BadRequest(format!("Invalid credential format: {e}")))?;
-
-        // Complete registration
-        let passkey = self
-            .state
-            .webauthn()
-            .read()
-            .await
-            .finish_passkey_registration(&credential, &reg_state)
-            .map_err(|e| {
-                // Provide user-friendly error messages for common WebAuthn errors
-                let error_msg = e.to_string();
-                if error_msg.contains("origin does not match") {
-                    HttpError::BadRequest(
-                        "Security error: The domain you're accessing from doesn't match the expected domain. \
-                        Please ensure you're accessing from the correct URL.".to_string()
-                    )
-                } else {
-                    HttpError::BadRequest(format!("Registration failed: {e}"))
-                }
-            })?;
-
-        // Get credential ID
-        let credential_id = URL_SAFE_NO_PAD.encode(passkey.cred_id());
-
-        // Clean up session
-        self.state.remove_session(&session_id).await;
-
-        Ok((passkey, credential_id, user_name))
-    }
-
-    /// Start authentication
-    pub async fn start_authentication(&self) -> Result<(serde_json::Value, String), HttpError> {
-        // Get all credentials
-        let credentials = self.backend.list_all_credentials().await.map_err(|e| {
-            HttpError::InternalServerError(format!("Failed to list credentials: {e}"))
-        })?;
-
-        if credentials.is_empty() {
-            return Err(HttpError::NotFound("No credentials registered".to_string()));
-        }
-
-        // Convert stored credentials back to passkeys
-        let mut passkeys: Vec<Passkey> = Vec::new();
-        for cred in credentials {
-            match serde_json::from_slice::<Passkey>(&cred.public_key) {
-                Ok(passkey) => passkeys.push(passkey),
-                Err(e) => {
-                    // Log error but continue with other credentials
-                    tracing::warn!(
-                        "Failed to deserialize passkey for credential {}: {}",
-                        cred.credential_id,
-                        e
-                    );
-                }
-            }
-        }
-
-        if passkeys.is_empty() {
-            return Err(HttpError::InternalServerError(
-                "No valid passkeys found in storage".to_string(),
-            ));
-        }
-
-        // Start authentication
-        let (rcr, auth_state) = self
-            .state
-            .webauthn()
-            .read()
-            .await
-            .start_passkey_authentication(&passkeys)
-            .map_err(|e| {
-                HttpError::InternalServerError(format!("Failed to start authentication: {e}"))
-            })?;
-
-        // Generate session ID
-        let session_id = WebAuthnState::generate_session_id();
-
-        // Store session
-        let session = WebAuthnSession {
-            user_name: None,
-            registration_state: None,
-            authentication_state: Some(auth_state),
-            created_at: Utc::now(),
-        };
-        self.state.store_session(session_id.clone(), session).await;
-
-        // Convert to JSON
-        let challenge_json = serde_json::to_value(rcr).map_err(|e| {
-            HttpError::InternalServerError(format!("Failed to serialize challenge: {e}"))
-        })?;
-
-        Ok((challenge_json, session_id))
-    }
-
-    /// Complete authentication
-    pub async fn complete_authentication(
-        &self,
-        session_id: String,
-        credential_json: serde_json::Value,
-    ) -> Result<(String, u32), HttpError> {
-        // Get session
-        let session = self
-            .state
-            .get_session(&session_id)
-            .await
-            .ok_or_else(|| HttpError::BadRequest("Invalid session".to_string()))?;
-
-        let auth_state = session
-            .authentication_state
-            .ok_or_else(|| HttpError::BadRequest("Invalid session state".to_string()))?;
-
-        // Deserialize the credential
-        let credential: PublicKeyCredential = serde_json::from_value(credential_json)
-            .map_err(|e| HttpError::BadRequest(format!("Invalid credential format: {e}")))?;
-
-        // Complete authentication
-        let auth_result = self
-            .state
-            .webauthn()
-            .read()
-            .await
-            .finish_passkey_authentication(&credential, &auth_state)
-            .map_err(|e| HttpError::AuthenticationFailed(format!("Invalid credential: {e}")))?;
-
-        // Get credential ID
-        let credential_id = URL_SAFE_NO_PAD.encode(auth_result.cred_id());
-
-        // Clean up session
-        self.state.remove_session(&session_id).await;
-
-        Ok((credential_id, auth_result.counter()))
-    }
-
-    /// Cleanup expired sessions periodically
-    pub async fn cleanup_sessions(&self) {
-        self.state.cleanup_expired_sessions().await;
-    }
-
-    /// Add a new allowed origin dynamically
-    pub async fn add_allowed_origin(&self, origin: String) -> Result<(), HttpError> {
-        self.state
-            .add_allowed_origin(origin)
-            .await
-            .map_err(|e| HttpError::InternalServerError(format!("Failed to add origin: {e}")))
-    }
-}
diff --git a/crates/daemon/src/sinks/catgrad_sink.rs b/crates/daemon/src/sinks/catgrad_sink.rs
deleted file mode 100644
index e5d3d419..00000000
--- a/crates/daemon/src/sinks/catgrad_sink.rs
+++ /dev/null
@@ -1,195 +0,0 @@
-use async_trait::async_trait;
-use catgrad_llm::serve::Loader;
-use futures::StreamExt;
-use gate_core::Result;
-use gate_core::router::prelude::{
-    ModelList, Protocol, RequestContext, RequestStream, ResponseChunk, Sink, SinkCapabilities,
-    SinkDescription, SinkHealth, StopReason,
-};
-use serde_json::json;
-use std::pin::Pin;
-
-use catgrad_llm::{
-    run::{ModelLoader, ModelRunner, ModelTokenizer},
-    serve::{ChatTokenizer, LM, Message, Tokenizer},
-};
-
-pub struct CatgradSink {
-    id: String,
-    models: Vec<String>,
-}
-
-impl CatgradSink {
-    pub fn new(id: impl Into<String>, models: Vec<String>) -> Self {
-        Self {
-            id: id.into(),
-            models,
-        }
-    }
-}
-
-#[async_trait]
-impl Sink for CatgradSink {
-    async fn describe(&self) -> SinkDescription {
-        // We can serve both OpenAI chat completions and Anthropic messages
-        SinkDescription {
-            id: self.id.clone(),
-            accepted_protocols: vec![Protocol::OpenAIChat, Protocol::Anthropic],
-            models: if self.models.is_empty() {
-                ModelList::Dynamic
-            } else {
-                ModelList::Static(self.models.clone())
-            },
-            capabilities: SinkCapabilities {
-                supports_streaming: true, // we emit a streaming response interface
-                supports_batching: false,
-                supports_tools: false,
-                max_context_length: Some(8192),
-                modalities: vec!["text".into()],
-            },
-            cost_structure: None,
-        }
-    }
-
-    async fn probe(&self) -> SinkHealth {
-        SinkHealth {
-            healthy: true,
-            latency_ms: Some(10),
-            error_rate: 0.0,
-            last_error: None,
-            last_check: chrono::Utc::now(),
-        }
-    }
-
-    async fn execute(
-        &self,
-        _ctx: &RequestContext,
-        mut request: RequestStream,
-    ) -> Result<Pin<Box<dyn futures::Stream<Item = Result<ResponseChunk>> + Send>>> {
-        let protocol = request.protocol();
-        #[inline]
-        fn internalize<E: std::fmt::Display>(e: E) -> gate_core::Error {
-            gate_core::Error::Internal(format!("{e}"))
-        }
-        // Take first request JSON
-        let first = request.next().await.ok_or_else(|| {
-            gate_core::Error::InvalidRoutingConfig("Empty request stream".to_string())
-        })??;
-
-        let model = first
-            .get("model")
-            .and_then(|v| v.as_str())
-            .unwrap_or("")
-            .to_string();
-
-        // Build messages in a simple, provider-agnostic way
-        let mut catgrad_messages: Vec<Message> = Vec::new();
-        if let Some(system) = first.get("system").and_then(|v| v.as_str()) {
-            catgrad_messages.push(Message {
-                role: "system".into(),
-                content: system.into(),
-            });
-        }
-        if let Some(msgs) = first.get("messages").and_then(|v| v.as_array()) {
-            for m in msgs {
-                let role = m
-                    .get("role")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or("user")
-                    .to_string();
-                // Handle string content or anthropic-style content blocks
-                let content = if let Some(s) = m.get("content").and_then(|v| v.as_str()) {
-                    s.to_string()
-                } else if let Some(arr) = m.get("content").and_then(|v| v.as_array()) {
-                    let mut s = String::new();
-                    for block in arr {
-                        if let Some(t) = block.get("type").and_then(|v| v.as_str())
-                            && t == "text"
-                            && let Some(txt) = block.get("text").and_then(|v| v.as_str())
-                        {
-                            s.push_str(txt);
-                            s.push('\n');
-                        }
-                    }
-                    s
-                } else {
-                    String::new()
-                };
-                catgrad_messages.push(Message { role, content });
-            }
-        }
-
-        let _temperature = first
-            .get("temperature")
-            .and_then(|v| v.as_f64())
-            .unwrap_or(0.7) as f32;
-        let max_tokens = first
-            .get("max_tokens")
-            .and_then(|v| v.as_u64())
-            .unwrap_or(256) as usize;
-
-        // Spawn blocking generation to compute deltas of decoded text and usage
-        let model_clone = model.clone();
-        let (deltas, prompt_tokens, completion_tokens): (Vec<String>, u32, u32) =
-            tokio::task::spawn_blocking(move || -> gate_core::Result<(Vec<String>, u32, u32)> {
-                let loader = ModelLoader::new(&model_clone, true).map_err(internalize)?;
-                let mut runner: ModelRunner = loader.load_runner().map_err(internalize)?;
-                let tokenizer: ModelTokenizer = loader.load_tokenizer().map_err(internalize)?;
-
-                let context = tokenizer
-                    .encode_messages(catgrad_messages)
-                    .map_err(internalize)?;
-                let prompt_len = context.len() as u32;
-
-                let mut deltas = Vec::new();
-                let mut count = 0usize;
-                for token in runner.complete(context) {
-                    // Decode only the current token to avoid cloning the full sequence
-                    if let Ok(piece) = tokenizer.decode(vec![token])
-                        && !piece.is_empty()
-                    {
-                        deltas.push(piece);
-                    }
-                    count += 1;
-                    if count >= max_tokens {
-                        break;
-                    }
-                }
-                Ok((deltas, prompt_len, count as u32))
-            })
-            .await
-            .map_err(internalize)??;
-
-        // Build a stream over headers, metadata, incremental deltas, usage, then Stop
-        let mut items: Vec<gate_core::Result<ResponseChunk>> = Vec::with_capacity(deltas.len() + 4);
-        items.push(Ok(ResponseChunk::Headers(Default::default())));
-        items.push(Ok(ResponseChunk::Metadata({
-            let mut m = std::collections::HashMap::new();
-            m.insert("provider".to_string(), json!("local"));
-            m.insert("model".to_string(), json!(model));
-            m
-        })));
-        for d in deltas {
-            let chunk_body = match protocol {
-                Protocol::OpenAIChat => json!({
-                    "choices": [{"index": 0, "delta": {"content": d}}]
-                }),
-                Protocol::Anthropic => json!({
-                    "content": [{"type": "text", "text": d}]
-                }),
-                _ => json!({"delta": d}),
-            };
-            items.push(Ok(ResponseChunk::Content(chunk_body)));
-        }
-        items.push(Ok(ResponseChunk::Usage {
-            prompt_tokens,
-            completion_tokens,
-        }));
-        items.push(Ok(ResponseChunk::Stop {
-            reason: StopReason::Complete,
-            error: None,
-            cost: None,
-        }));
-        Ok(Box::pin(futures::stream::iter(items)))
-    }
-}
diff --git a/crates/daemon/src/sinks/mod.rs b/crates/daemon/src/sinks/mod.rs
deleted file mode 100644
index 7f112876..00000000
--- a/crates/daemon/src/sinks/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub mod catgrad_sink;
diff --git a/crates/daemon/src/state.rs b/crates/daemon/src/state.rs
deleted file mode 100644
index 599eacf0..00000000
--- a/crates/daemon/src/state.rs
+++ /dev/null
@@ -1,261 +0,0 @@
-//! State for HTTP routes
-//!
-//! This module provides the state required for HTTP routes to function.
-//! It contains the auth service (for middleware) and the daemon handle (for business logic).
-
-use crate::Daemon;
-use crate::config::ProviderPassthroughConfig;
-use crate::services::AuthService;
-use async_trait::async_trait;
-use axum::extract::connect_info::ConnectInfo;
-use axum::http::HeaderName;
-use axum::http::request::Parts;
-use gate_core::router::signals::{anthropic_key_from, openai_bearer_from};
-use gate_http::error::HttpError;
-use gate_http::middleware::AuthProvider;
-use gate_http::services::{HttpContext, HttpIdentity};
-use std::net::SocketAddr;
-use std::sync::Arc;
-
-/// State for HTTP routes
-#[derive(Clone)]
-pub struct State {
-    /// Auth service for middleware authentication
-    pub auth_service: Arc<AuthService>,
-    /// Daemon handle for all business logic
-    pub daemon: Daemon,
-    /// Whether to allow localhost peer to bypass auth
-    pub allow_local_bypass: bool,
-    /// Provider passthrough configuration
-    pub provider_passthrough: ProviderPassthroughConfig,
-}
-
-impl State {
-    pub fn new(
-        auth_service: Arc<AuthService>,
-        daemon: Daemon,
-        allow_local_bypass: bool,
-        provider_passthrough: ProviderPassthroughConfig,
-    ) -> Self {
-        Self {
-            auth_service,
-            daemon,
-            allow_local_bypass,
-            provider_passthrough,
-        }
-    }
-}
-
-// Implement AuthProvider directly for State
-#[async_trait]
-impl AuthProvider for State {
-    async fn authenticate(&self, parts: &Parts) -> Result<HttpIdentity, HttpError> {
-        // Helper: detect Anthropic API key from headers
-        fn detect_anthropic_key(parts: &Parts) -> Option<String> {
-            anthropic_key_from(&parts.headers).map(|s| s.to_string())
-        }
-
-        // Helper: detect OpenAI API key from headers
-        fn detect_openai_key(parts: &Parts) -> Option<String> {
-            if let Some(tok) = openai_bearer_from(&parts.headers) {
-                return Some(tok.to_string());
-            }
-            if let Some(val) = parts
-                .headers
-                .get(HeaderName::from_static("x-api-key"))
-                .and_then(|v| v.to_str().ok())
-                && !val.is_empty()
-            {
-                return Some(val.to_string());
-            }
-            None
-        }
-
-        let path = parts.uri.path();
-        // Provider-token auth bypass for Anthropic/OpenAI, gated by config
-        let passthrough_allowed_path = self
-            .provider_passthrough
-            .allowed_paths
-            .iter()
-            .any(|p| p == path);
-        let is_loopback = parts
-            .extensions
-            .get::<ConnectInfo<SocketAddr>>()
-            .map(|c| c.0.ip().is_loopback())
-            .unwrap_or(false);
-        if self.provider_passthrough.enabled
-            && passthrough_allowed_path
-            && (!self.provider_passthrough.loopback_only || is_loopback)
-        {
-            if let Some(_anthropic_key) = detect_anthropic_key(parts) {
-                let identity = HttpIdentity::new(
-                    "provider:anthropic".to_string(),
-                    "anthropic-key".to_string(),
-                    HttpContext::new()
-                        .with_attribute("auth_method", "provider-key")
-                        .with_attribute("provider", "anthropic")
-                        .with_attribute("node_id", "local"),
-                );
-                return Ok(identity);
-            }
-            if let Some(_openai_key) = detect_openai_key(parts) {
-                let identity = HttpIdentity::new(
-                    "provider:openai".to_string(),
-                    "openai-key".to_string(),
-                    HttpContext::new()
-                        .with_attribute("auth_method", "provider-key")
-                        .with_attribute("provider", "openai")
-                        .with_attribute("node_id", "local"),
-                );
-                return Ok(identity);
-            }
-        }
-
-        if let Some(auth_header) = parts
-            .headers
-            .get("Authorization")
-            .and_then(|value| value.to_str().ok())
-        {
-            // Default JWT auth
-            return self.auth_service.authenticate_from_header(auth_header);
-        }
-
-        // If auth header is missing, allow localhost bypass when enabled and peer is loopback
-        if self.allow_local_bypass {
-            if let Some(connect_info) = parts.extensions.get::<ConnectInfo<SocketAddr>>() {
-                let ip = connect_info.0.ip();
-                if ip.is_loopback() {
-                    let identity = HttpIdentity::new(
-                        "local".to_string(),
-                        "loopback".to_string(),
-                        HttpContext::new()
-                            .with_attribute("auth_method", "loopback")
-                            .with_attribute("node_id", "local")
-                            .with_attribute("is_owner", "true"),
-                    );
-                    info!("Granted localhost bypass for peer {}", ip);
-                    return Ok(identity);
-                } else {
-                    debug!("Localhost bypass not applied: peer {} not loopback", ip);
-                }
-            } else {
-                debug!("Localhost bypass not applied: missing ConnectInfo");
-            }
-        }
-
-        Err(HttpError::AuthenticationFailed(
-            "Missing authorization header".to_string(),
-        ))
-    }
-
-    fn should_skip_auth(&self, path: &str) -> bool {
-        path.starts_with("/auth/webauthn/")
-            || path.starts_with("/auth/bootstrap/")
-            || path == "/health"
-            || path.starts_with("/swagger-ui")
-            || path == "/"
-            || path.ends_with(".js")
-            || path.ends_with(".wasm")
-            || path.ends_with(".html")
-            || path.ends_with(".css")
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::daemon::rpc::DaemonRequest;
-    use axum::http::Request;
-    use gate_core::access::IdentityContext;
-    use gate_http::services::JwtService;
-    use gate_http::services::jwt::JwtConfig as JwtSvcConfig;
-    use gate_sqlx::SqliteStateBackend;
-    use tokio::sync::mpsc;
-
-    async fn make_minimal_state(allow_local_bypass: bool) -> State {
-        // Build a lightweight AuthService stack (will not be exercised in these tests)
-        let jwt_service = Arc::new(JwtService::new(JwtSvcConfig::new(
-            "test-secret".to_string(),
-            24,
-            "test-issuer".to_string(),
-        )));
-
-        // In-memory state backend and webauthn backend
-        let state_backend = Arc::new(SqliteStateBackend::new(":memory:").await.unwrap());
-        let webauthn_backend = Arc::new(gate_sqlx::SqliteWebAuthnBackend::new(
-            state_backend.pool().clone(),
-        ));
-
-        let auth_service = Arc::new(AuthService::new(
-            jwt_service,
-            state_backend,
-            webauthn_backend,
-        ));
-
-        // Dummy daemon handle
-        let (tx, _rx) = mpsc::channel::<DaemonRequest>(1);
-        let daemon = crate::daemon::Daemon::new(tx, None);
-
-        State::new(
-            auth_service,
-            daemon,
-            allow_local_bypass,
-            crate::config::ProviderPassthroughConfig::default(),
-        )
-    }
-
-    #[tokio::test]
-    async fn test_loopback_bypass_allows_without_auth() {
-        let state = make_minimal_state(true).await;
-
-        let req: Request<()> = Request::builder().uri("/api/config").body(()).unwrap();
-        let (mut parts, _body) = req.into_parts();
-        parts
-            .extensions
-            .insert(ConnectInfo::<SocketAddr>(SocketAddr::from((
-                [127, 0, 0, 1],
-                1234,
-            ))));
-
-        let ident = state
-            .authenticate(&parts)
-            .await
-            .expect("expected bypass identity");
-        assert_eq!(ident.source, "loopback");
-        assert_eq!(ident.context.get("is_owner"), Some("true"));
-    }
-
-    #[tokio::test]
-    async fn test_non_loopback_rejects_without_auth() {
-        let state = make_minimal_state(true).await;
-
-        let req: Request<()> = Request::builder().uri("/").body(()).unwrap();
-        let (mut parts, _body) = req.into_parts();
-        parts
-            .extensions
-            .insert(ConnectInfo::<SocketAddr>(SocketAddr::from((
-                [192, 168, 1, 10],
-                5555,
-            ))));
-
-        let res = state.authenticate(&parts).await;
-        assert!(matches!(res, Err(HttpError::AuthenticationFailed(_))));
-    }
-
-    #[tokio::test]
-    async fn test_loopback_rejects_when_toggle_disabled() {
-        let state = make_minimal_state(false).await;
-
-        let req: Request<()> = Request::builder().uri("/").body(()).unwrap();
-        let (mut parts, _body) = req.into_parts();
-        parts
-            .extensions
-            .insert(ConnectInfo::<SocketAddr>(SocketAddr::from((
-                [127, 0, 0, 1],
-                9999,
-            ))));
-
-        let res = state.authenticate(&parts).await;
-        assert!(matches!(res, Err(HttpError::AuthenticationFailed(_))));
-    }
-}
diff --git a/crates/daemon/src/state_dir.rs b/crates/daemon/src/state_dir.rs
deleted file mode 100644
index 9f29906b..00000000
--- a/crates/daemon/src/state_dir.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-//! Platform-specific state directory management
-use crate::DaemonError;
-use directories::ProjectDirs;
-use std::path::PathBuf;
-
-/// Manages platform-specific application directories
-pub struct StateDir(ProjectDirs);
-
-impl StateDir {
-    /// Create a new StateDir instance
-    pub async fn new() -> Result<Self, DaemonError> {
-        let dirs = ProjectDirs::from("com.hellas", "Gate", "Gate")
-            .ok_or(DaemonError::PlatformDirsNotFound)?;
-        let me = Self(dirs);
-        me.create_directories().await?;
-        Ok(me)
-    }
-
-    /// Create all required directories
-    pub async fn create_directories(&self) -> Result<(), DaemonError> {
-        let config_dir = self.0.config_local_dir();
-        let data_dir = self.0.data_local_dir();
-
-        let dirs_to_create = vec![config_dir, data_dir];
-        for dir in &dirs_to_create {
-            tokio::fs::create_dir_all(&dir).await?;
-            debug!("Ensured directory exists: {}", dir.display());
-        }
-
-        debug!("Using state directories:");
-        debug!("  Config: {}", config_dir.display());
-        debug!("  Data: {}", data_dir.display());
-
-        Ok(())
-    }
-
-    /// Get the configuration directory
-    pub fn config_dir(&self) -> PathBuf {
-        self.0.config_local_dir().to_path_buf()
-    }
-
-    /// Get the data directory for persistent storage
-    pub fn data_dir(&self) -> PathBuf {
-        self.0.data_local_dir().to_path_buf()
-    }
-
-    /// Get the directory for storing keys
-    pub fn dir_for(&self, component: &str) -> PathBuf {
-        self.data_dir().join(component)
-    }
-
-    /// Get the config path
-    pub fn config_path(&self) -> PathBuf {
-        self.config_dir().join("config.json")
-    }
-
-    /// Get the path for the Iroh secret key
-    pub fn iroh_secret_key_path(&self) -> PathBuf {
-        self.config_dir().join("iroh_secret.key")
-    }
-}
diff --git a/crates/daemon/src/tls_reload.rs b/crates/daemon/src/tls_reload.rs
deleted file mode 100644
index 96c1f144..00000000
--- a/crates/daemon/src/tls_reload.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//! Dynamic TLS acceptor that can be reloaded with new certificates
-
-use gate_tlsforward::TlsAcceptorProvider;
-use std::future::Future;
-use std::pin::Pin;
-use std::sync::Arc;
-use tokio::sync::RwLock;
-use tokio_rustls::TlsAcceptor;
-
-/// A TLS acceptor that can be dynamically reloaded with new certificates
-#[derive(Clone)]
-pub struct ReloadableTlsAcceptor {
-    inner: Arc<RwLock<TlsAcceptor>>,
-}
-
-impl ReloadableTlsAcceptor {
-    /// Create a new reloadable TLS acceptor
-    pub fn new(acceptor: TlsAcceptor) -> Self {
-        Self {
-            inner: Arc::new(RwLock::new(acceptor)),
-        }
-    }
-
-    /// Get the current TLS acceptor
-    pub async fn get(&self) -> TlsAcceptor {
-        self.inner.read().await.clone()
-    }
-
-    /// Update the TLS acceptor with a new one
-    pub async fn reload(&self, new_acceptor: TlsAcceptor) {
-        *self.inner.write().await = new_acceptor;
-    }
-}
-
-impl TlsAcceptorProvider for ReloadableTlsAcceptor {
-    fn get_acceptor(&self) -> Pin<Box<dyn Future<Output = TlsAcceptor> + Send + '_>> {
-        Box::pin(self.get())
-    }
-}
diff --git a/crates/daemon/src/types.rs b/crates/daemon/src/types.rs
deleted file mode 100644
index 58d2fb50..00000000
--- a/crates/daemon/src/types.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct DaemonStatus {
-    pub running: bool,
-    pub listen_address: String,
-    pub provider_count: usize,
-    pub user_count: usize,
-    pub tlsforward_enabled: bool,
-    pub tlsforward_status: TlsForwardStatus,
-    pub needs_bootstrap: bool,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum TlsForwardStatus {
-    Disabled,
-    Disconnected,
-    Connecting,
-    Connected { domain: String },
-    Error(String),
-}
-
-/// Response for bootstrap status endpoint
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct BootstrapStatusResponse {
-    /// Whether the system needs bootstrap (no users exist)
-    pub needs_bootstrap: bool,
-    /// Whether bootstrap process is complete
-    pub is_complete: bool,
-    /// Human-readable status message
-    pub message: String,
-}
-
-/// Response for daemon runtime configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct DaemonRuntimeConfigResponse {
-    /// Server address the daemon is listening on
-    pub server_address: String,
-    /// Whether TLS forward is enabled
-    pub tlsforward_enabled: bool,
-}
diff --git a/crates/daemon/tests/routes_build.rs b/crates/daemon/tests/routes_build.rs
deleted file mode 100644
index a1a21bac..00000000
--- a/crates/daemon/tests/routes_build.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-use axum::Router;
-use gate_daemon::{
-    State,
-    routes::{admin, auth, config},
-};
-
-// Ensure admin routes construct without panicking (e.g., invalid path syntax)
-#[test]
-fn admin_routes_builds() {
-    let _ = admin::add_routes(Router::<gate_http::AppState<State>>::new());
-}
-
-// Ensure auth routes construct without panicking
-#[test]
-fn auth_routes_builds() {
-    let _ = auth::add_routes(Router::<gate_http::AppState<State>>::new());
-}
-
-// Ensure config routes construct without panicking
-#[test]
-fn config_routes_builds() {
-    let _ = config::add_routes(Router::<gate_http::AppState<State>>::new());
-}
diff --git a/crates/fixtures/Cargo.toml b/crates/fixtures/Cargo.toml
deleted file mode 100644
index d3425138..00000000
--- a/crates/fixtures/Cargo.toml
+++ /dev/null
@@ -1,14 +0,0 @@
-[package]
-name = "gate-fixtures"
-version.workspace = true
-edition.workspace = true
-authors.workspace = true
-license.workspace = true
-repository.workspace = true
-
-[dependencies]
-serde = { workspace = true }
-serde_json = { workspace = true }
-
-[build-dependencies]
-walkdir = "2.5"
diff --git a/crates/fixtures/README.md b/crates/fixtures/README.md
deleted file mode 100644
index ec6fe1b1..00000000
Binary files a/crates/fixtures/README.md and /dev/null differ
diff --git a/crates/fixtures/build.rs b/crates/fixtures/build.rs
deleted file mode 100644
index 97156471..00000000
--- a/crates/fixtures/build.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-use std::env;
-use std::fs;
-use std::path::Path;
-use walkdir::WalkDir;
-
-fn main() {
-    let out_dir = env::var("OUT_DIR").unwrap();
-    let dest_path = Path::new(&out_dir).join("cassettes.rs");
-
-    let mut cassette_list = String::new();
-    cassette_list.push_str("// Auto-generated file listing all cassettes\n\n");
-    cassette_list.push_str("pub const CASSETTES: &[(&str, &str, &str)] = &[\n");
-
-    // Walk through the data directory
-    for entry in WalkDir::new("data")
-        .into_iter()
-        .filter_map(Result::ok)
-        .filter(|e| e.file_type().is_file())
-    {
-        let path = entry.path();
-        let relative_path = path.strip_prefix("data").unwrap();
-
-        // Extract provider and test name from path
-        let components: Vec<&str> = relative_path
-            .to_str()
-            .unwrap()
-            .split('/')
-            .filter(|s| !s.is_empty())
-            .collect();
-
-        if components.len() >= 2 {
-            let provider = components[0];
-            let filename = components[components.len() - 1];
-            let test_name = filename
-                .trim_end_matches(".json")
-                .trim_end_matches(".enhanced_json")
-                .trim_end_matches(".yaml");
-
-            cassette_list.push_str(&format!(
-                "    (\"{}\", \"{}\", include_str!(concat!(env!(\"CARGO_MANIFEST_DIR\"), \"/{}\"))),\n",
-                provider, test_name, path.display()
-            ));
-        }
-    }
-
-    cassette_list.push_str("];\n");
-
-    fs::write(&dest_path, cassette_list).unwrap();
-
-    // Tell cargo to rerun this script if the data directory changes
-    println!("cargo:rerun-if-changed=data");
-}
diff --git a/crates/fixtures/conftest.py b/crates/fixtures/conftest.py
deleted file mode 100644
index 8758e148..00000000
--- a/crates/fixtures/conftest.py
+++ /dev/null
@@ -1,240 +0,0 @@
-"""
-Enhanced pytest configuration for LLM API fixture capture using pytest-recording.
-
-This configuration provides:
-- JSON format cassettes with rich metadata
-- Timing information capture
-- Streaming response preservation
-- Hierarchical cassette organization
-- Dual-mode testing (streaming and non-streaming)
-"""
-
-import os
-import json
-import time
-import base64
-from typing import Dict, Any, List, Optional
-from datetime import datetime, timezone
-import pytest
-import vcr
-from dotenv import load_dotenv
-import serializer
-
-# Load environment variables from .env file
-load_dotenv()
-
-
-# Store timing info globally to work with dict-like request objects
-_request_timings = {}
-
-
-def add_timing_metadata(request, response):
-    """Add timing information to the response metadata."""
-    # Handle both dict-like VCR requests and httpx Request objects
-    if hasattr(request, 'method') and hasattr(request, 'url'):
-        # httpx Request object
-        method = request.method
-        uri = str(request.url)
-    else:
-        # VCR dict format
-        method = request.get('method', '')
-        uri = request.get('uri', '')
-    
-    # Generate a unique request key
-    request_key = f"{method}:{uri}"
-    
-    # Record timing in response headers (will be preserved in cassette)
-    if request_key in _request_timings:
-        elapsed_ms = int((time.time() - _request_timings[request_key]) * 1000)
-        response['headers']['X-VCR-Elapsed-Ms'] = [str(elapsed_ms)]
-        # Clean up
-        del _request_timings[request_key]
-    
-    # Add timestamp
-    response['headers']['X-VCR-Recorded-At'] = [datetime.now(timezone.utc).isoformat()]
-    
-    return response
-
-
-def before_record_request(request):
-    """Process request before recording."""
-    # Handle both dict-like VCR requests and httpx Request objects
-    if hasattr(request, 'method') and hasattr(request, 'url'):
-        # httpx Request object
-        method = request.method
-        uri = str(request.url)
-    else:
-        # VCR dict format
-        method = request.get('method', '')
-        uri = request.get('uri', '')
-    
-    # Store timing marker
-    request_key = f"{method}:{uri}"
-    _request_timings[request_key] = time.time()
-    
-    # Only process headers for dict-like requests
-    if isinstance(request, dict) and 'headers' in request:
-        # Normalize header names to lowercase
-        request['headers'] = {k.lower(): v for k, v in request['headers'].items()}
-    
-    return request
-
-
-def before_record_response(response):
-    """Process response before recording, preserving SSE structure."""
-    # Add timestamp
-    if 'headers' not in response:
-        response['headers'] = {}
-    response['headers']['X-VCR-Recorded-At'] = [datetime.now(timezone.utc).isoformat()]
-    
-    # For SSE responses, ensure we capture the raw event stream
-    content_type = ''
-    if 'headers' in response:
-        for header, value in response['headers'].items():
-            if header.lower() == 'content-type':
-                content_type = value[0] if isinstance(value, list) else value
-                break
-    
-    # Mark SSE responses for special handling
-    if 'text/event-stream' in content_type:
-        response['headers']['X-VCR-SSE-Response'] = ['true']
-    
-    return response
-
-
-@pytest.fixture(scope='module')
-def vcr_config():
-    """Configure VCR for all tests using pytest-recording."""
-    return {
-        'serializer': 'json',
-        'record_mode': os.environ.get('VCR_RECORD_MODE', 'once'),
-        'match_on': ['method', 'scheme', 'host', 'port', 'path', 'query'],
-        'filter_headers': [
-            ('authorization', 'REDACTED'),
-            ('x-api-key', 'REDACTED'),
-            ('api-key', 'REDACTED'),
-            ('openai-api-key', 'REDACTED'),
-        ],
-        'decode_compressed_response': True,
-        'before_record_request': before_record_request,
-        'before_record_response': before_record_response,
-    }
-
-
-@pytest.fixture
-def vcr_cassette_dir(request):
-    """Organize cassettes by provider and API."""
-    # Get test file path
-    test_file = request.node.fspath
-    test_name = test_file.purebasename
-    
-    # Determine provider and API from test file name
-    if 'openai' in test_name:
-        if 'chat_completions' in test_name:
-            subdir = 'openai/chat_completions'
-        elif 'responses' in test_name:
-            subdir = 'openai/responses'
-        else:
-            subdir = 'openai/other'
-    elif 'anthropic' in test_name:
-        subdir = 'anthropic/messages'
-    else:
-        subdir = 'other'
-    
-    cassette_dir = os.path.join('data', subdir)
-    os.makedirs(cassette_dir, exist_ok=True)
-    return cassette_dir
-
-
-def pytest_recording_configure(config, vcr):
-    """Hook to configure VCR instance with our custom serializer."""
-    # Register the custom serializer from serializer.py
-    vcr.register_serializer('json', serializer)
-
-
-@pytest.fixture
-def default_cassette_name(request):
-    """Generate cassette name with streaming suffix when applicable."""
-    test_name = request.node.name
-    
-    # Remove test_ prefix if present
-    if test_name.startswith('test_'):
-        test_name = test_name[5:]
-    
-    # Check if this is a streaming test
-    if hasattr(request, 'param') and getattr(request.param, 'streaming', False):
-        test_name += '_streaming'
-    
-    # Handle parametrized tests
-    if '[' in test_name:
-        # Clean up parameter names for filesystem
-        test_name = test_name.replace('[', '_').replace(']', '').replace('-', '_')
-    
-    return test_name + '.json'  # Use .json extension
-
-
-class APITestConfig:
-    """Configuration for API tests."""
-    
-    def __init__(self, streaming: bool = False):
-        self.streaming = streaming
-        self.api_key_env_var = None
-        self.skip_if_no_key = True
-
-
-@pytest.fixture(params=[
-    APITestConfig(streaming=False),
-    APITestConfig(streaming=True)
-], ids=['non_streaming', 'streaming'])
-def api_mode(request):
-    """Fixture that provides both streaming and non-streaming test modes."""
-    return request.param
-
-
-@pytest.fixture
-def check_api_key(vcr_config):
-    """Helper fixture to check for API keys."""
-    def _check(env_var: str, skip: bool = True):
-        api_key = os.environ.get(env_var)
-        # In replay mode (once), we can use a dummy key since VCR will replay
-        if not api_key:
-            record_mode = vcr_config.get('record_mode', 'once')
-            if record_mode == 'once':
-                # Use dummy key for replay mode
-                return "dummy-key-for-vcr-replay"
-            elif skip:
-                pytest.skip(f"{env_var} environment variable not set")
-        return api_key
-    return _check
-
-
-# Environment variable validation
-@pytest.fixture(scope='session', autouse=True)
-def validate_environment():
-    """Validate test environment and provide warnings."""
-    warnings = []
-    
-    # Check for API keys
-    if not os.environ.get('OPENAI_API_KEY'):
-        warnings.append("OPENAI_API_KEY not set - OpenAI tests will be skipped")
-    
-    if not os.environ.get('ANTHROPIC_API_KEY'):
-        warnings.append("ANTHROPIC_API_KEY not set - Anthropic tests will be skipped")
-    
-    # Check for cassette directory
-    if not os.path.exists('data'):
-        os.makedirs('data')
-    
-    # Print warnings
-    if warnings:
-        print("\n=== Test Environment Warnings ===")
-        for warning in warnings:
-            print(f"  ⚠️  {warning}")
-        print("=================================\n")
-
-
-@pytest.fixture
-def sample_image_base64():
-    """Provide a small test image in base64 format."""
-    # 1x1 red pixel PNG
-    return "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg=="
\ No newline at end of file
diff --git a/crates/fixtures/data/anthropic/messages/basic_message.json b/crates/fixtures/data/anthropic/messages/basic_message.json
deleted file mode 100644
index aee2a7e6..00000000
--- a/crates/fixtures/data/anthropic/messages/basic_message.json
+++ /dev/null
@@ -1,164 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"max_tokens\":100,\"messages\":[{\"role\":\"user\",\"content\":\"What is the capital of France? Answer in one word.\"}],\"model\":\"claude-sonnet-4-0\",\"temperature\":0}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "154"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-timeout": [
-            "600"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "{\"id\":\"msg_01SrMcY1k4NqhYzDFVoMjBfd\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[{\"type\":\"text\",\"text\":\"Paris\"}],\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":19,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":4,\"service_tier\":\"standard\"}}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597cf0b1f9abb10-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:37:41 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:37:41.409949+00:00"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:37:41Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:37:41Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:37:39Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:37:41Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "329"
-          ],
-          "request-id": [
-            "req_011CQkQv1oWMMnWHWfHZmFtE"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:37:41.413644+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/anthropic/messages/multi_turn_conversation.json b/crates/fixtures/data/anthropic/messages/multi_turn_conversation.json
deleted file mode 100644
index c20561d6..00000000
--- a/crates/fixtures/data/anthropic/messages/multi_turn_conversation.json
+++ /dev/null
@@ -1,319 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"max_tokens\":150,\"messages\":[{\"role\":\"user\",\"content\":\"My name is Alice and I love astronomy. Remember this.\"}],\"model\":\"claude-sonnet-4-0\"}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "141"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-timeout": [
-            "600"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "{\"id\":\"msg_01LotNwKvHyDm95hhTAVieWD\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[{\"type\":\"text\",\"text\":\"Nice to meet you, Alice! I'll remember that you love astronomy. That's a fascinating field - there's so much to explore from planets and stars to galaxies and cosmic phenomena. Is there any particular area of astronomy that interests you most?\"}],\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":19,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":53,\"service_tier\":\"standard\"}}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597d4487e7ecd00-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:41:18 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:41:18.637678+00:00"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:41:17Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:41:18Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:41:14Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:41:17Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "568"
-          ],
-          "request-id": [
-            "req_011CQkRBqT79AmwLbZoFvs3q"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"max_tokens\":150,\"messages\":[{\"role\":\"user\",\"content\":\"My name is Alice and I love astronomy. Remember this.\"},{\"role\":\"assistant\",\"content\":[{\"text\":\"Nice to meet you, Alice! I'll remember that you love astronomy. That's a fascinating field - there's so much to explore from planets and stars to galaxies and cosmic phenomena. Is there any particular area of astronomy that interests you most?\",\"type\":\"text\"}]},{\"role\":\"user\",\"content\":\"What's my name and what do I love?\"}],\"model\":\"claude-sonnet-4-0\"}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "506"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-timeout": [
-            "600"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "{\"id\":\"msg_01PeRFostCBDRBbz8huBCRmh\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[{\"type\":\"text\",\"text\":\"Your name is Alice and you love astronomy!\"}],\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":85,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":12,\"service_tier\":\"standard\"}}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597d4638a56cd00-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:41:21 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:41:21.092811+00:00"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:41:20Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:41:21Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:41:18Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:41:20Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "367"
-          ],
-          "request-id": [
-            "req_011CQkRC9sdQk8ufJvV6g7at"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:41:21.093963+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/anthropic/messages/parallel_tool_calls.json b/crates/fixtures/data/anthropic/messages/parallel_tool_calls.json
deleted file mode 100644
index 90a6e900..00000000
--- a/crates/fixtures/data/anthropic/messages/parallel_tool_calls.json
+++ /dev/null
@@ -1,319 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"max_tokens\":1024,\"messages\":[{\"role\":\"user\",\"content\":\"Calculate the area of a rectangle with length 10 and width 5, and also calculate the perimeter. Show me both calculations.\"}],\"model\":\"claude-sonnet-4-0\",\"tools\":[{\"name\":\"calculate\",\"description\":\"Perform mathematical calculations\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"expression\":{\"type\":\"string\",\"description\":\"Mathematical expression to evaluate\"}},\"required\":[\"expression\"]}}]}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "449"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-timeout": [
-            "600"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "{\"id\":\"msg_01SEACP4UaYdevjmEAy7aZNS\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[{\"type\":\"text\",\"text\":\"I'll calculate both the area and perimeter of the rectangle for you.\"},{\"type\":\"tool_use\",\"id\":\"toolu_01FXdqaXqZ3MkkNkK2BeJzKz\",\"name\":\"calculate\",\"input\":{\"expression\":\"10 * 5\"}},{\"type\":\"tool_use\",\"id\":\"toolu_01RWu92FXD28LH6gcwRNopnr\",\"name\":\"calculate\",\"input\":{\"expression\":\"2 * (10 + 5)\"}}],\"stop_reason\":\"tool_use\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":407,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":113,\"service_tier\":\"standard\"}}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597dcaabb412355-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:47:00 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:47:00.840111+00:00"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:46:59Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:47:00Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:46:57Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:46:59Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "619"
-          ],
-          "request-id": [
-            "req_011CQkRd9bTbBfUmfqGuYaBe"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"max_tokens\":1024,\"messages\":[{\"role\":\"user\",\"content\":\"Calculate the area of a rectangle with length 10 and width 5, and also calculate the perimeter. Show me both calculations.\"},{\"role\":\"assistant\",\"content\":[{\"text\":\"I'll calculate both the area and perimeter of the rectangle for you.\",\"type\":\"text\"},{\"id\":\"toolu_01FXdqaXqZ3MkkNkK2BeJzKz\",\"input\":{\"expression\":\"10 * 5\"},\"name\":\"calculate\",\"type\":\"tool_use\"},{\"id\":\"toolu_01RWu92FXD28LH6gcwRNopnr\",\"input\":{\"expression\":\"2 * (10 + 5)\"},\"name\":\"calculate\",\"type\":\"tool_use\"}]},{\"role\":\"user\",\"content\":[{\"type\":\"tool_result\",\"tool_use_id\":\"toolu_01FXdqaXqZ3MkkNkK2BeJzKz\",\"content\":\"50\"},{\"type\":\"tool_result\",\"tool_use_id\":\"toolu_01RWu92FXD28LH6gcwRNopnr\",\"content\":\"30\"}]}],\"model\":\"claude-sonnet-4-0\",\"tools\":[{\"name\":\"calculate\",\"description\":\"Perform mathematical calculations\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"expression\":{\"type\":\"string\",\"description\":\"Mathematical expression to evaluate\"}},\"required\":[\"expression\"]}}]}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "998"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-timeout": [
-            "600"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "{\"id\":\"msg_01ACN8PUonhEnPhUx72U5URh\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[{\"type\":\"text\",\"text\":\"Here are the calculations for your rectangle:\\n\\n**Area calculation:**\\n- Formula: Area = length \u00d7 width\\n- Area = 10 \u00d7 5 = **50 square units**\\n\\n**Perimeter calculation:**\\n- Formula: Perimeter = 2 \u00d7 (length + width)\\n- Perimeter = 2 \u00d7 (10 + 5) = 2 \u00d7 15 = **30 units**\\n\\nSo the rectangle has an area of 50 square units and a perimeter of 30 units.\"}],\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":581,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":121,\"service_tier\":\"standard\"}}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597dcbe4cf32355-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:47:04 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:47:04.097812+00:00"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:47:03Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:47:04Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:47:00Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:47:03Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "682"
-          ],
-          "request-id": [
-            "req_011CQkRdNyNSh8MuCY232y23"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:47:04.098827+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/anthropic/messages/stop_sequences.json b/crates/fixtures/data/anthropic/messages/stop_sequences.json
deleted file mode 100644
index 876bc6ae..00000000
--- a/crates/fixtures/data/anthropic/messages/stop_sequences.json
+++ /dev/null
@@ -1,164 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"max_tokens\":200,\"messages\":[{\"role\":\"user\",\"content\":\"Write a short story. End each sentence with a period.\"}],\"model\":\"claude-sonnet-4-0\",\"stop_sequences\":[\".\",\"!\",\"?\"],\"temperature\":0.8}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "190"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-timeout": [
-            "600"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "{\"id\":\"msg_01Vj4CVCKTqVDmu7HPr9JfpK\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[{\"type\":\"text\",\"text\":\"**The Last Light**\\n\\nEmma climbed the lighthouse stairs for what she knew would be the final time\"}],\"stop_reason\":\"stop_sequence\",\"stop_sequence\":\".\",\"usage\":{\"input_tokens\":19,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":22,\"service_tier\":\"standard\"}}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597dcd2cf1f1a65-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:47:07 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:47:07.628554+00:00"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:47:05Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:47:07Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:47:04Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:47:05Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "427"
-          ],
-          "request-id": [
-            "req_011CQkRdczV6DUn6dDJJ5Fzr"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:47:07.629620+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/anthropic/messages/streaming_basic.json b/crates/fixtures/data/anthropic/messages/streaming_basic.json
deleted file mode 100644
index 249a7e35..00000000
--- a/crates/fixtures/data/anthropic/messages/streaming_basic.json
+++ /dev/null
@@ -1,331 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"max_tokens\":100,\"messages\":[{\"role\":\"user\",\"content\":\"Count from 1 to 5, one number per line.\"}],\"model\":\"claude-sonnet-4-0\",\"temperature\":0,\"stream\":true}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "157"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-stream-helper": [
-            "messages"
-          ],
-          "x-stainless-timeout": [
-            "NOT_GIVEN"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "event: ping\ndata: {\"type\": \"ping\"}\n\nevent: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_01TRL4fHEqpfx8nAUYq7qWfr\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[],\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":21,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":1,\"service_tier\":\"standard\"}}               }\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"text\",\"text\":\"\"}       }\n\nevent: ping\ndata: {\"type\": \"ping\"}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"1\\n2\\n3\\n4\\n5\"}           }\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0      }\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"end_turn\",\"stop_sequence\":null},\"usage\":{\"output_tokens\":13}             }\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"        }\n\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597d239be31be81-ZRH"
-          ],
-          "Cache-Control": [
-            "no-cache"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "text/event-stream; charset=utf-8"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:40:20 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:40:31.372159+00:00"
-          ],
-          "X-VCR-SSE-Response": [
-            "true"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:39:50Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:39:50Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:39:50Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:39:50Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "request-id": [
-            "req_011CQkR5d7Y4z7wr1nDMM1Ni"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"max_tokens\":50,\"messages\":[{\"role\":\"user\",\"content\":\"Count from 1 to 5, one number per line.\"},{\"role\":\"assistant\",\"content\":[{\"citations\":null,\"text\":\"1\\n2\\n3\\n4\\n5\",\"type\":\"text\"}]},{\"role\":\"user\",\"content\":\"What number comes after 5?\"}],\"model\":\"claude-sonnet-4-0\",\"stream\":true}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "284"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-stream-helper": [
-            "messages"
-          ],
-          "x-stainless-timeout": [
-            "NOT_GIVEN"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_01WpiTo5bVZfW5AfpC6Arckf\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[],\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":44,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":5,\"service_tier\":\"standard\"}}          }\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"text\",\"text\":\"\"} }\n\nevent: ping\ndata: {\"type\": \"ping\"}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"6\"}     }\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0 }\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"end_turn\",\"stop_sequence\":null},\"usage\":{\"output_tokens\":5}              }\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"         }\n\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597d33c295dbe81-ZRH"
-          ],
-          "Cache-Control": [
-            "no-cache"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "text/event-stream; charset=utf-8"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:40:33 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:40:33.885737+00:00"
-          ],
-          "X-VCR-SSE-Response": [
-            "true"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:40:31Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:40:31Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:40:31Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:40:31Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "request-id": [
-            "req_011CQkR8fsKDqjb7ZhLb1vVu"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:40:33.887239+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/anthropic/messages/streaming_with_tool_use.json b/crates/fixtures/data/anthropic/messages/streaming_with_tool_use.json
deleted file mode 100644
index 7ceb7411..00000000
--- a/crates/fixtures/data/anthropic/messages/streaming_with_tool_use.json
+++ /dev/null
@@ -1,331 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"max_tokens\":1024,\"messages\":[{\"role\":\"user\",\"content\":\"What's the weather in Paris? Then calculate 25 * 4.\"}],\"model\":\"claude-sonnet-4-0\",\"tools\":[{\"name\":\"get_weather\",\"description\":\"Get current weather for a location\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"location\":{\"type\":\"string\",\"description\":\"City and state, e.g. San Francisco, CA\"},\"unit\":{\"type\":\"string\",\"enum\":[\"celsius\",\"fahrenheit\"],\"description\":\"Temperature unit\",\"default\":\"fahrenheit\"}},\"required\":[\"location\"]}},{\"name\":\"calculate\",\"description\":\"Perform mathematical calculations\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"expression\":{\"type\":\"string\",\"description\":\"Mathematical expression to evaluate\"}},\"required\":[\"expression\"]}}],\"stream\":true}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "735"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-stream-helper": [
-            "messages"
-          ],
-          "x-stainless-timeout": [
-            "NOT_GIVEN"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "event: ping\ndata: {\"type\": \"ping\"}\n\nevent: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_01M7kg4qdpMdt5uWVnw3MpdK\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[],\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":500,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":7,\"service_tier\":\"standard\"}}          }\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"text\",\"text\":\"\"}            }\n\nevent: ping\ndata: {\"type\": \"ping\"}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"I'll help you get the weather\"} }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\" in Paris and calculate 25 * 4.\"}   }\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0      }\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":1,\"content_block\":{\"type\":\"tool_use\",\"id\":\"toolu_018EFMzab8MCi1nxCbKYdxuC\",\"name\":\"get_weather\",\"input\":{}}          }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":1,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"\"}  }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":1,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"{\\\"location\\\"\"} }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":1,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\": \\\"\"}           }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":1,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"Pa\"}  }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":1,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"ris, Fran\"}   }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":1,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"ce\\\"}\"}        }\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":1               }\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":2,\"content_block\":{\"type\":\"tool_use\",\"id\":\"toolu_01L7ERtnisXjnrDKRUeTa1sc\",\"name\":\"calculate\",\"input\":{}}          }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":2,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"\"}              }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":2,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"{\\\"expres\"}            }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":2,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"sion\\\"\"}         }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":2,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\": \\\"25 \"}          }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":2,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"* 4\\\"}\"}       }\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":2           }\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"tool_use\",\"stop_sequence\":null},\"usage\":{\"output_tokens\":112}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\" }\n\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597dce8e842bc11-ZRH"
-          ],
-          "Cache-Control": [
-            "no-cache"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "text/event-stream; charset=utf-8"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:47:38 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:47:53.800145+00:00"
-          ],
-          "X-VCR-SSE-Response": [
-            "true"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "199000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:47:08Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:47:08Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:47:08Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "279000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:47:08Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "request-id": [
-            "req_011CQkRdtMTP3LYTaSMaHHuD"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"max_tokens\":1024,\"messages\":[{\"role\":\"user\",\"content\":\"What's the weather in Paris? Then calculate 25 * 4.\"},{\"role\":\"assistant\",\"content\":[{\"citations\":null,\"text\":\"I'll help you get the weather in Paris and calculate 25 * 4.\",\"type\":\"text\"},{\"id\":\"toolu_018EFMzab8MCi1nxCbKYdxuC\",\"input\":{\"location\":\"Paris, France\"},\"name\":\"get_weather\",\"type\":\"tool_use\"},{\"id\":\"toolu_01L7ERtnisXjnrDKRUeTa1sc\",\"input\":{\"expression\":\"25 * 4\"},\"name\":\"calculate\",\"type\":\"tool_use\"}]},{\"role\":\"user\",\"content\":[{\"type\":\"tool_result\",\"tool_use_id\":\"toolu_018EFMzab8MCi1nxCbKYdxuC\",\"content\":\"{\\\"location\\\": \\\"Paris, France\\\", \\\"temperature\\\": 18, \\\"conditions\\\": \\\"Sunny\\\", \\\"humidity\\\": 60, \\\"wind_speed\\\": 10}\"},{\"type\":\"tool_result\",\"tool_use_id\":\"toolu_01L7ERtnisXjnrDKRUeTa1sc\",\"content\":\"100\"}]}],\"model\":\"claude-sonnet-4-0\",\"tools\":[{\"name\":\"get_weather\",\"description\":\"Get current weather for a location\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"location\":{\"type\":\"string\",\"description\":\"City and state, e.g. San Francisco, CA\"},\"unit\":{\"type\":\"string\",\"enum\":[\"celsius\",\"fahrenheit\"],\"description\":\"Temperature unit\",\"default\":\"fahrenheit\"}},\"required\":[\"location\"]}},{\"name\":\"calculate\",\"description\":\"Perform mathematical calculations\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"expression\":{\"type\":\"string\",\"description\":\"Mathematical expression to evaluate\"}},\"required\":[\"expression\"]}}],\"stream\":true}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "1412"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-stream-helper": [
-            "messages"
-          ],
-          "x-stainless-timeout": [
-            "NOT_GIVEN"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "event: ping\ndata: {\"type\": \"ping\"}\n\nevent: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_01RGTkeUoA7NGA4fnfEUDoUT\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[],\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":708,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":2,\"service_tier\":\"standard\"}}   }\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"text\",\"text\":\"\"}               }\n\nevent: ping\ndata: {\"type\": \"ping\"}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"Here are\"}      }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\" your results:\\n\\n**Weather in Paris,\"}        }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\" France:**\\n- Temperature: 18\"}    }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"\u00b0F\\n- Conditions: Sunny\\n-\"}     }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\" Humidity: 60%\\n- Wind Speed: 10 mph\"}   }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"\\n\\n**Calculation:**\\n25 \u00d7 4 = 100\"}          }\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0            }\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"end_turn\",\"stop_sequence\":null},\"usage\":{\"output_tokens\":63}               }\n\nevent: message_stop\ndata: {\"type\":\"message_stop\" }\n\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597de095fb3bc11-ZRH"
-          ],
-          "Cache-Control": [
-            "no-cache"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "text/event-stream; charset=utf-8"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:48:24 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:48:35.317620+00:00"
-          ],
-          "X-VCR-SSE-Response": [
-            "true"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "199000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:47:54Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:47:53Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:47:53Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "279000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:47:53Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "request-id": [
-            "req_011CQkRhHT6u7my9SYrDhYh4"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:48:35.319223+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/anthropic/messages/system_prompt.json b/crates/fixtures/data/anthropic/messages/system_prompt.json
deleted file mode 100644
index a62b4eb0..00000000
--- a/crates/fixtures/data/anthropic/messages/system_prompt.json
+++ /dev/null
@@ -1,319 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"max_tokens\":100,\"messages\":[{\"role\":\"user\",\"content\":\"Hello, how are you today?\"}],\"model\":\"claude-sonnet-4-0\",\"system\":\"You are a pirate. Always respond in pirate speak, starting with 'Arrr!'\",\"temperature\":0.7}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "214"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-timeout": [
-            "600"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "{\"id\":\"msg_01UuUWQhUJJL8gQQG8J1LosA\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[{\"type\":\"text\",\"text\":\"Arrr! Ahoy there, me hearty! I be doin' fine as frog's hair on this fine day, sailin' the digital seas with the wind at me back! Me spirits be high as the crow's nest, and I be ready for whatever adventures ye might be bringin' me way. \\n\\nHow be ye farin' today, ye scurvy landlubber? Got any tales of treasure or daring deeds to share with\"}],\"stop_reason\":\"max_tokens\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":35,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":100,\"service_tier\":\"standard\"}}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597d4812ad8bc62-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:41:27 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:41:27.167366+00:00"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:41:24Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:41:27Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:41:23Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:41:24Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "669"
-          ],
-          "request-id": [
-            "req_011CQkRCWAmQanvAV8u8YB5i"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"max_tokens\":150,\"messages\":[{\"role\":\"user\",\"content\":\"Hello, how are you today?\"},{\"role\":\"assistant\",\"content\":[{\"text\":\"Arrr! Ahoy there, me hearty! I be doin' fine as frog's hair on this fine day, sailin' the digital seas with the wind at me back! Me spirits be high as the crow's nest, and I be ready for whatever adventures ye might be bringin' me way. \\n\\nHow be ye farin' today, ye scurvy landlubber? Got any tales of treasure or daring deeds to share with\",\"type\":\"text\"}]},{\"role\":\"user\",\"content\":\"What's your favorite treasure?\"}],\"model\":\"claude-sonnet-4-0\",\"system\":\"You are a pirate. Always respond in pirate speak, starting with 'Arrr!'\",\"temperature\":0.7}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "673"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-timeout": [
-            "600"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "{\"id\":\"msg_01UxSYp2btGDu6skXLNaskan\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[{\"type\":\"text\",\"text\":\"Arrr! Me favorite treasure, ye ask? Well, shiver me timbers, that be a fine question indeed! \\n\\nWhile most scallywags be chasin' after chests of doubloons and pieces of eight, this old sea dog's greatest treasure be knowledge itself! Aye, the wisdom of the seven seas, the secrets of navigation by the stars, and the tales of legendary pirates who sailed these waters before me - that be worth more than all the Spanish gold in Davy Jones' locker!\\n\\nBut if I be honest, matey, there be nothin' quite like a well-drawn map with a big red X markin' the spot where untold riches be burie\"}],\"stop_reason\":\"max_tokens\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":147,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":150,\"service_tier\":\"standard\"}}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597d498cdc3bc62-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:41:31 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:41:31.803105+00:00"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:41:28Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:41:31Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:41:27Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:41:28Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "915"
-          ],
-          "request-id": [
-            "req_011CQkRCnNqohG5ThY5B1EZL"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:41:31.804042+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/anthropic/messages/tool_choice_options.json b/crates/fixtures/data/anthropic/messages/tool_choice_options.json
deleted file mode 100644
index dc2ac25e..00000000
--- a/crates/fixtures/data/anthropic/messages/tool_choice_options.json
+++ /dev/null
@@ -1,629 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"max_tokens\":200,\"messages\":[{\"role\":\"user\",\"content\":\"Tell me a joke about programming.\"}],\"model\":\"claude-sonnet-4-0\",\"tool_choice\":{\"type\":\"auto\"},\"tools\":[{\"name\":\"get_weather\",\"description\":\"Get current weather for a location\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"location\":{\"type\":\"string\",\"description\":\"City and state, e.g. San Francisco, CA\"},\"unit\":{\"type\":\"string\",\"enum\":[\"celsius\",\"fahrenheit\"],\"description\":\"Temperature unit\",\"default\":\"fahrenheit\"}},\"required\":[\"location\"]}}]}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "504"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-timeout": [
-            "600"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "{\"id\":\"msg_016QykW6qwnpob3bikLKynfh\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[{\"type\":\"text\",\"text\":\"Here's a programming joke for you:\\n\\nWhy do programmers prefer dark mode?\\n\\nBecause light attracts bugs! \ud83d\udc1b\\n\\nAnd here's a bonus one:\\n\\nA SQL query walks into a bar, walks up to two tables and asks, \\\"Can I join you?\\\"\\n\\nHope that gave you a good chuckle! Programming humor tends to be quite punny, doesn't it?\"}],\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":432,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":86,\"service_tier\":\"standard\"}}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597df0cefb5bc47-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:48:38 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:48:38.815261+00:00"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:48:37Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:48:38Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:48:35Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:48:37Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "643"
-          ],
-          "request-id": [
-            "req_011CQkRkLzFykvwRLsF4SgQw"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"max_tokens\":200,\"messages\":[{\"role\":\"user\",\"content\":\"Tell me a joke about programming.\"},{\"role\":\"assistant\",\"content\":[{\"text\":\"Here's a programming joke for you:\\n\\nWhy do programmers prefer dark mode?\\n\\nBecause light attracts bugs! \ud83d\udc1b\\n\\nAnd here's a bonus one:\\n\\nA SQL query walks into a bar, walks up to two tables and asks, \\\"Can I join you?\\\"\\n\\nHope that gave you a good chuckle! Programming humor tends to be quite punny, doesn't it?\",\"type\":\"text\"}]},{\"role\":\"user\",\"content\":\"Thanks! Now what's the weather in London?\"}],\"model\":\"claude-sonnet-4-0\",\"tool_choice\":{\"type\":\"auto\"},\"tools\":[{\"name\":\"get_weather\",\"description\":\"Get current weather for a location\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"location\":{\"type\":\"string\",\"description\":\"City and state, e.g. San Francisco, CA\"},\"unit\":{\"type\":\"string\",\"enum\":[\"celsius\",\"fahrenheit\"],\"description\":\"Temperature unit\",\"default\":\"fahrenheit\"}},\"required\":[\"location\"]}}]}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "950"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-timeout": [
-            "600"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "{\"id\":\"msg_01DMVXetTAjW4c2V6Zb2BAus\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[{\"type\":\"tool_use\",\"id\":\"toolu_01Au3hdE51MBM6voQsfxJbfi\",\"name\":\"get_weather\",\"input\":{\"location\":\"London, UK\"}}],\"stop_reason\":\"tool_use\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":531,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":55,\"service_tier\":\"standard\"}}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597df229d10bc47-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:49:20 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:49:20.972167+00:00"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:49:19Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:49:20Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:48:39Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:49:19Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "413"
-          ],
-          "request-id": [
-            "req_011CQkRkc3dVmRGCEf9j7Aac"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"max_tokens\":200,\"messages\":[{\"role\":\"user\",\"content\":\"What is 15 plus 27?\"}],\"model\":\"claude-sonnet-4-0\",\"tool_choice\":{\"type\":\"any\"},\"tools\":[{\"name\":\"calculate\",\"description\":\"Perform mathematical calculations\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"expression\":{\"type\":\"string\",\"description\":\"Mathematical expression to evaluate\"}},\"required\":[\"expression\"]}}]}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "374"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-timeout": [
-            "600"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "{\"id\":\"msg_01Tmrk77AXErrb22iNMkHrdQ\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[{\"type\":\"tool_use\",\"id\":\"toolu_01VNW8uFemdMTY71JCo1Vb7a\",\"name\":\"calculate\",\"input\":{\"expression\":\"15 + 27\"}}],\"stop_reason\":\"tool_use\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":390,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":40,\"service_tier\":\"standard\"}}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597e02a2b55bab4-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:49:22 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:49:22.687907+00:00"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:49:22Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:49:22Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:49:21Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:49:22Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "410"
-          ],
-          "request-id": [
-            "req_011CQkRoi95MYp9XkS1s9NdY"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"max_tokens\":200,\"messages\":[{\"role\":\"user\",\"content\":\"What is 15 plus 27?\"},{\"role\":\"assistant\",\"content\":[{\"id\":\"toolu_01VNW8uFemdMTY71JCo1Vb7a\",\"input\":{\"expression\":\"15 + 27\"},\"name\":\"calculate\",\"type\":\"tool_use\"}]},{\"role\":\"user\",\"content\":[{\"type\":\"tool_result\",\"tool_use_id\":\"toolu_01VNW8uFemdMTY71JCo1Vb7a\",\"content\":\"42\"}]}],\"model\":\"claude-sonnet-4-0\",\"tools\":[{\"name\":\"calculate\",\"description\":\"Perform mathematical calculations\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"expression\":{\"type\":\"string\",\"description\":\"Mathematical expression to evaluate\"}},\"required\":[\"expression\"]}}]}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "601"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-timeout": [
-            "600"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "{\"id\":\"msg_01VdSadzaXrSKdfP9DBDN2Jb\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[{\"type\":\"text\",\"text\":\"15 plus 27 equals 42.\"}],\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":457,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":13,\"service_tier\":\"standard\"}}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597e034da6ebab4-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:50:05 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:50:05.560964+00:00"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:50:05Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:50:05Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:49:22Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:50:05Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "347"
-          ],
-          "request-id": [
-            "req_011CQkRoqRd4N6nTaEu1eJf4"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:50:05.561936+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/anthropic/messages/tool_use_multi_turn.json b/crates/fixtures/data/anthropic/messages/tool_use_multi_turn.json
deleted file mode 100644
index 3afe2cf0..00000000
--- a/crates/fixtures/data/anthropic/messages/tool_use_multi_turn.json
+++ /dev/null
@@ -1,319 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"max_tokens\":1024,\"messages\":[{\"role\":\"user\",\"content\":\"What's the weather like in San Francisco and New York? Compare them.\"}],\"model\":\"claude-sonnet-4-0\",\"tools\":[{\"name\":\"get_weather\",\"description\":\"Get current weather for a location\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"location\":{\"type\":\"string\",\"description\":\"City and state, e.g. San Francisco, CA\"},\"unit\":{\"type\":\"string\",\"enum\":[\"celsius\",\"fahrenheit\"],\"description\":\"Temperature unit\",\"default\":\"fahrenheit\"}},\"required\":[\"location\"]}}]}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "510"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-timeout": [
-            "600"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "{\"id\":\"msg_01MeFwPrLpUQ3THKvELU8mhN\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[{\"type\":\"text\",\"text\":\"I'll get the current weather for both San Francisco and New York so I can compare them for you.\"},{\"type\":\"tool_use\",\"id\":\"toolu_01XKb4HZxj1tWLWSbjtTZ3ac\",\"name\":\"get_weather\",\"input\":{\"location\":\"San Francisco, CA\"}},{\"type\":\"tool_use\",\"id\":\"toolu_014Pmenh6bGeHb3aeifV8hyB\",\"name\":\"get_weather\",\"input\":{\"location\":\"New York, NY\"}}],\"stop_reason\":\"tool_use\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":440,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":117,\"service_tier\":\"standard\"}}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597cf160a590200-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:38:21 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:38:21.988637+00:00"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:38:21Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:38:21Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:37:41Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:38:21Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "657"
-          ],
-          "request-id": [
-            "req_011CQkQv9JTSiNT3nbPxYTed"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"max_tokens\":1024,\"messages\":[{\"role\":\"user\",\"content\":\"What's the weather like in San Francisco and New York? Compare them.\"},{\"role\":\"assistant\",\"content\":[{\"text\":\"I'll get the current weather for both San Francisco and New York so I can compare them for you.\",\"type\":\"text\"},{\"id\":\"toolu_01XKb4HZxj1tWLWSbjtTZ3ac\",\"input\":{\"location\":\"San Francisco, CA\"},\"name\":\"get_weather\",\"type\":\"tool_use\"},{\"id\":\"toolu_014Pmenh6bGeHb3aeifV8hyB\",\"input\":{\"location\":\"New York, NY\"},\"name\":\"get_weather\",\"type\":\"tool_use\"}]},{\"role\":\"user\",\"content\":[{\"type\":\"tool_result\",\"tool_use_id\":\"toolu_01XKb4HZxj1tWLWSbjtTZ3ac\",\"content\":\"{\\\"location\\\": \\\"San Francisco, CA\\\", \\\"temperature\\\": 65, \\\"conditions\\\": \\\"Partly cloudy\\\", \\\"humidity\\\": 70, \\\"wind_speed\\\": 12}\"},{\"type\":\"tool_result\",\"tool_use_id\":\"toolu_014Pmenh6bGeHb3aeifV8hyB\",\"content\":\"{\\\"location\\\": \\\"New York, NY\\\", \\\"temperature\\\": 45, \\\"conditions\\\": \\\"Clear\\\", \\\"humidity\\\": 50, \\\"wind_speed\\\": 8}\"}]}],\"model\":\"claude-sonnet-4-0\",\"tools\":[{\"name\":\"get_weather\",\"description\":\"Get current weather for a location\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"location\":{\"type\":\"string\",\"description\":\"City and state, e.g. San Francisco, CA\"},\"unit\":{\"type\":\"string\",\"enum\":[\"celsius\",\"fahrenheit\"],\"description\":\"Temperature unit\",\"default\":\"fahrenheit\"}},\"required\":[\"location\"]}}]}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "1341"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-timeout": [
-            "600"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "{\"id\":\"msg_01D6AN3ohZuMiPJNU59CaFTo\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[{\"type\":\"text\",\"text\":\"Here's the current weather comparison between San Francisco and New York:\\n\\n**San Francisco, CA:**\\n- Temperature: 65\u00b0F\\n- Conditions: Partly cloudy\\n- Humidity: 70%\\n- Wind Speed: 12 mph\\n\\n**New York, NY:**\\n- Temperature: 45\u00b0F\\n- Conditions: Clear\\n- Humidity: 50%\\n- Wind Speed: 8 mph\\n\\n**Comparison:**\\n- **Temperature**: San Francisco is significantly warmer (20\u00b0F difference), with San Francisco at 65\u00b0F compared to New York's 45\u00b0F\\n- **Sky Conditions**: New York has clearer skies, while San Francisco is partly cloudy\\n- **Humidity**: San Francisco is more humid at 70% compared to New York's 50%\\n- **Wind**: San Francisco is experiencing stronger winds at 12 mph versus New York's 8 mph\\n\\nOverall, San Francisco has milder, more humid weather with some cloud cover, while New York is cooler and drier but with clearer skies.\"}],\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":691,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":236,\"service_tier\":\"standard\"}}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597d013790f0200-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:39:02 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:39:02.632008+00:00"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:39:02Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:39:02Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:38:22Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:39:02Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "1170"
-          ],
-          "request-id": [
-            "req_011CQkQy8erFNqCayShi7rvw"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:39:02.632927+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/anthropic/messages/vision_image_analysis.json b/crates/fixtures/data/anthropic/messages/vision_image_analysis.json
deleted file mode 100644
index c83703c0..00000000
--- a/crates/fixtures/data/anthropic/messages/vision_image_analysis.json
+++ /dev/null
@@ -1,319 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"max_tokens\":200,\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"What animal is in this image? Answer in one word.\"},{\"type\":\"image\",\"source\":{\"type\":\"url\",\"url\":\"https://placecats.com/200/200\"}}]}],\"model\":\"claude-sonnet-4-0\"}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "241"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-timeout": [
-            "600"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "{\"id\":\"msg_01PVpFJzJiRU8z2rzo7wQG2c\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[{\"type\":\"text\",\"text\":\"Cat\"}],\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":86,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":4,\"service_tier\":\"standard\"}}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597d928ed23739d-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:44:36 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:44:36.763751+00:00"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:44:35Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:44:36Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:44:34Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:44:35Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "327"
-          ],
-          "request-id": [
-            "req_011CQkRSZQ8GMGFn6roRu76H"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"max_tokens\":200,\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"What animal is in this image? Answer in one word.\"},{\"type\":\"image\",\"source\":{\"type\":\"url\",\"url\":\"https://placecats.com/200/200\"}}]},{\"role\":\"assistant\",\"content\":[{\"text\":\"Cat\",\"type\":\"text\"}]},{\"role\":\"user\",\"content\":\"What is the cat doing? Is it sleeping, sitting, or playing?\"}],\"model\":\"claude-sonnet-4-0\"}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "anthropic-version": [
-            "2023-06-01"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "391"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.anthropic.com"
-          ],
-          "user-agent": [
-            "AsyncAnthropic/Python 0.55.0"
-          ],
-          "x-api-key": [
-            "REDACTED"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "0.55.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ],
-          "x-stainless-timeout": [
-            "600"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.anthropic.com/v1/messages"
-      },
-      "response": {
-        "body": {
-          "string": "{\"id\":\"msg_012YCoMktbPDG91evFPnjGUr\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-4-20250514\",\"content\":[{\"type\":\"text\",\"text\":\"Sitting\"}],\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"usage\":{\"input_tokens\":108,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":5,\"service_tier\":\"standard\"}}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597d939c90d739d-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:44:38 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Robots-Tag": [
-            "none"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:44:38.558321+00:00"
-          ],
-          "anthropic-organization-id": [
-            "39c87378-13ee-4a61-905b-a9ba8eae3dcc"
-          ],
-          "anthropic-ratelimit-input-tokens-limit": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-remaining": [
-            "200000"
-          ],
-          "anthropic-ratelimit-input-tokens-reset": [
-            "2025-07-03T16:44:38Z"
-          ],
-          "anthropic-ratelimit-output-tokens-limit": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-remaining": [
-            "80000"
-          ],
-          "anthropic-ratelimit-output-tokens-reset": [
-            "2025-07-03T16:44:38Z"
-          ],
-          "anthropic-ratelimit-requests-limit": [
-            "4000"
-          ],
-          "anthropic-ratelimit-requests-remaining": [
-            "3999"
-          ],
-          "anthropic-ratelimit-requests-reset": [
-            "2025-07-03T16:44:36Z"
-          ],
-          "anthropic-ratelimit-tokens-limit": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-remaining": [
-            "280000"
-          ],
-          "anthropic-ratelimit-tokens-reset": [
-            "2025-07-03T16:44:38Z"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "332"
-          ],
-          "request-id": [
-            "req_011CQkRSm1sfTqkYgrJTfjJP"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "via": [
-            "1.1 google"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:44:38.559342+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/cassettes_index.json b/crates/fixtures/data/cassettes_index.json
deleted file mode 100644
index 129e33cc..00000000
--- a/crates/fixtures/data/cassettes_index.json
+++ /dev/null
@@ -1,226 +0,0 @@
-[
-  {
-    "provider": "anthropic",
-    "category": "messages",
-    "name": "basic_message",
-    "display_name": "Basic Message",
-    "path": "/cassettes/anthropic/messages/basic_message.json"
-  },
-  {
-    "provider": "anthropic",
-    "category": "messages",
-    "name": "multi_turn_conversation",
-    "display_name": "Multi Turn Conversation",
-    "path": "/cassettes/anthropic/messages/multi_turn_conversation.json"
-  },
-  {
-    "provider": "anthropic",
-    "category": "messages",
-    "name": "parallel_tool_calls",
-    "display_name": "Parallel Tool Calls",
-    "path": "/cassettes/anthropic/messages/parallel_tool_calls.json"
-  },
-  {
-    "provider": "anthropic",
-    "category": "messages",
-    "name": "stop_sequences",
-    "display_name": "Stop Sequences",
-    "path": "/cassettes/anthropic/messages/stop_sequences.json"
-  },
-  {
-    "provider": "anthropic",
-    "category": "messages",
-    "name": "streaming_basic",
-    "display_name": "Streaming Basic",
-    "path": "/cassettes/anthropic/messages/streaming_basic.json"
-  },
-  {
-    "provider": "anthropic",
-    "category": "messages",
-    "name": "streaming_with_tool_use",
-    "display_name": "Streaming With Tool Use",
-    "path": "/cassettes/anthropic/messages/streaming_with_tool_use.json"
-  },
-  {
-    "provider": "anthropic",
-    "category": "messages",
-    "name": "system_prompt",
-    "display_name": "System Prompt",
-    "path": "/cassettes/anthropic/messages/system_prompt.json"
-  },
-  {
-    "provider": "anthropic",
-    "category": "messages",
-    "name": "tool_choice_options",
-    "display_name": "Tool Choice Options",
-    "path": "/cassettes/anthropic/messages/tool_choice_options.json"
-  },
-  {
-    "provider": "anthropic",
-    "category": "messages",
-    "name": "tool_use_multi_turn",
-    "display_name": "Tool Use Multi Turn",
-    "path": "/cassettes/anthropic/messages/tool_use_multi_turn.json"
-  },
-  {
-    "provider": "anthropic",
-    "category": "messages",
-    "name": "vision_image_analysis",
-    "display_name": "Vision Image Analysis",
-    "path": "/cassettes/anthropic/messages/vision_image_analysis.json"
-  },
-  {
-    "provider": "openai",
-    "category": "chat_completions",
-    "name": "basic_chat_completion",
-    "display_name": "Basic Chat Completion",
-    "path": "/cassettes/openai/chat_completions/basic_chat_completion.json"
-  },
-  {
-    "provider": "openai",
-    "category": "chat_completions",
-    "name": "function_calling",
-    "display_name": "Function Calling",
-    "path": "/cassettes/openai/chat_completions/function_calling.json"
-  },
-  {
-    "provider": "openai",
-    "category": "chat_completions",
-    "name": "json_mode",
-    "display_name": "Json Mode",
-    "path": "/cassettes/openai/chat_completions/json_mode.json"
-  },
-  {
-    "provider": "openai",
-    "category": "chat_completions",
-    "name": "logprobs",
-    "display_name": "Logprobs",
-    "path": "/cassettes/openai/chat_completions/logprobs.json"
-  },
-  {
-    "provider": "openai",
-    "category": "chat_completions",
-    "name": "max_tokens_and_stop_sequence",
-    "display_name": "Max Tokens And Stop Sequence",
-    "path": "/cassettes/openai/chat_completions/max_tokens_and_stop_sequence.json"
-  },
-  {
-    "provider": "openai",
-    "category": "chat_completions",
-    "name": "multi_turn_conversation",
-    "display_name": "Multi Turn Conversation",
-    "path": "/cassettes/openai/chat_completions/multi_turn_conversation.json"
-  },
-  {
-    "provider": "openai",
-    "category": "chat_completions",
-    "name": "parallel_tool_calls",
-    "display_name": "Parallel Tool Calls",
-    "path": "/cassettes/openai/chat_completions/parallel_tool_calls.json"
-  },
-  {
-    "provider": "openai",
-    "category": "chat_completions",
-    "name": "streaming_chat_completion",
-    "display_name": "Streaming Chat Completion",
-    "path": "/cassettes/openai/chat_completions/streaming_chat_completion.json"
-  },
-  {
-    "provider": "openai",
-    "category": "chat_completions",
-    "name": "structured_output_pydantic",
-    "display_name": "Structured Output Pydantic",
-    "path": "/cassettes/openai/chat_completions/structured_output_pydantic.json"
-  },
-  {
-    "provider": "openai",
-    "category": "chat_completions",
-    "name": "structured_output_with_tool_use",
-    "display_name": "Structured Output With Tool Use",
-    "path": "/cassettes/openai/chat_completions/structured_output_with_tool_use.json"
-  },
-  {
-    "provider": "openai",
-    "category": "chat_completions",
-    "name": "system_message_instructions",
-    "display_name": "System Message Instructions",
-    "path": "/cassettes/openai/chat_completions/system_message_instructions.json"
-  },
-  {
-    "provider": "openai",
-    "category": "responses",
-    "name": "assistant_asks_yes_no_question",
-    "display_name": "Assistant Asks Yes No Question",
-    "path": "/cassettes/openai/responses/assistant_asks_yes_no_question.json"
-  },
-  {
-    "provider": "openai",
-    "category": "responses",
-    "name": "assistant_multiple_choice_question",
-    "display_name": "Assistant Multiple Choice Question",
-    "path": "/cassettes/openai/responses/assistant_multiple_choice_question.json"
-  },
-  {
-    "provider": "openai",
-    "category": "responses",
-    "name": "assistant_preference_question",
-    "display_name": "Assistant Preference Question",
-    "path": "/cassettes/openai/responses/assistant_preference_question.json"
-  },
-  {
-    "provider": "openai",
-    "category": "responses",
-    "name": "basic_response",
-    "display_name": "Basic Response",
-    "path": "/cassettes/openai/responses/basic_response.json"
-  },
-  {
-    "provider": "openai",
-    "category": "responses",
-    "name": "basic_streaming",
-    "display_name": "Basic Streaming",
-    "path": "/cassettes/openai/responses/basic_streaming.json"
-  },
-  {
-    "provider": "openai",
-    "category": "responses",
-    "name": "conversation_flow_with_structured_responses",
-    "display_name": "Conversation Flow With Structured Responses",
-    "path": "/cassettes/openai/responses/conversation_flow_with_structured_responses.json"
-  },
-  {
-    "provider": "openai",
-    "category": "responses",
-    "name": "conversation_with_context",
-    "display_name": "Conversation With Context",
-    "path": "/cassettes/openai/responses/conversation_with_context.json"
-  },
-  {
-    "provider": "openai",
-    "category": "responses",
-    "name": "function_calling_non_streaming",
-    "display_name": "Function Calling Non Streaming",
-    "path": "/cassettes/openai/responses/function_calling_non_streaming.json"
-  },
-  {
-    "provider": "openai",
-    "category": "responses",
-    "name": "function_calling_streaming",
-    "display_name": "Function Calling Streaming",
-    "path": "/cassettes/openai/responses/function_calling_streaming.json"
-  },
-  {
-    "provider": "openai",
-    "category": "responses",
-    "name": "instructions_parameter",
-    "display_name": "Instructions Parameter",
-    "path": "/cassettes/openai/responses/instructions_parameter.json"
-  },
-  {
-    "provider": "openai",
-    "category": "responses",
-    "name": "structured_output_pydantic",
-    "display_name": "Structured Output Pydantic",
-    "path": "/cassettes/openai/responses/structured_output_pydantic.json"
-  }
-]
diff --git a/crates/fixtures/data/openai/chat_completions/basic_chat_completion.json b/crates/fixtures/data/openai/chat_completions/basic_chat_completion.json
deleted file mode 100644
index becb943d..00000000
--- a/crates/fixtures/data/openai/chat_completions/basic_chat_completion.json
+++ /dev/null
@@ -1,156 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"messages\":[{\"role\":\"system\",\"content\":\"You are a helpful assistant.\"},{\"role\":\"user\",\"content\":\"What is the capital of France? Answer in one word.\"}],\"model\":\"gpt-4o-mini\",\"max_tokens\":10,\"temperature\":0}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "206"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.91.0"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "1.91.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/chat/completions"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"chatcmpl-BpGgFtizHnuPj8Pk9Z9O1NYvRXwSE\",\n  \"object\": \"chat.completion\",\n  \"created\": 1751558547,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"Paris.\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 29,\n    \"completion_tokens\": 2,\n    \"total_tokens\": 31,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\": \"default\",\n  \"system_fingerprint\": \"fp_62a23a81ef\"\n}\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "95979b764f12ef5b-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:02:28 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=EZf5tSz.Y7IhSd0l3s.g2t76ndyJP0jW3Ns6tpQgYVM-1751558548-1.0.1.1-M3sxnX0qSkN2Wh5GDMpDL_hw_YZosOmDgFJWcLh65O_r3ak28JHcsy3.LvVpZPFS5xGH8jL5Ox0AcEO0FJhCaZlNUyt509lwkyPCXXM9jPo; path=/; expires=Thu, 03-Jul-25 16:32:28 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=VdV7qSX3W.45a9pNe3qoEagRge2VI3S6pnWENlSq5yM-1751558548233-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:02:28.236705+00:00"
-          ],
-          "access-control-expose-headers": [
-            "X-Request-ID"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "812"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "278"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-envoy-upstream-service-time": [
-            "285"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999977"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "0s"
-          ],
-          "x-request-id": [
-            "req_40df146169509b5d7f9fc47bc4cfb463"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:02:28.238984+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/chat_completions/function_calling.json b/crates/fixtures/data/openai/chat_completions/function_calling.json
deleted file mode 100644
index 6a05cf80..00000000
--- a/crates/fixtures/data/openai/chat_completions/function_calling.json
+++ /dev/null
@@ -1,302 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"messages\":[{\"role\":\"user\",\"content\":\"What's the weather like in San Francisco and New York? Compare them.\"}],\"model\":\"gpt-4o-mini\",\"tool_choice\":\"auto\",\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"description\":\"Get current weather for a location\",\"parameters\":{\"type\":\"object\",\"properties\":{\"location\":{\"type\":\"string\",\"description\":\"City and state, e.g. San Francisco, CA\"},\"unit\":{\"type\":\"string\",\"enum\":[\"celsius\",\"fahrenheit\"],\"description\":\"Temperature unit\"}},\"required\":[\"location\"]}}}]}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "513"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.91.0"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "1.91.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/chat/completions"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"chatcmpl-BpGnesd1f0lEU3ncsXHr6KBQR7Zsq\",\n  \"object\": \"chat.completion\",\n  \"created\": 1751559006,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": null,\n        \"tool_calls\": [\n          {\n            \"id\": \"call_gFEN8BVfsxigdXcfza7HYcI6\",\n            \"type\": \"function\",\n            \"function\": {\n              \"name\": \"get_weather\",\n              \"arguments\": \"{\\\"location\\\": \\\"San Francisco, CA\\\", \\\"unit\\\": \\\"celsius\\\"}\"\n            }\n          },\n          {\n            \"id\": \"call_Sk5K6CrRUZ6v186eL5LFMFyR\",\n            \"type\": \"function\",\n            \"function\": {\n              \"name\": \"get_weather\",\n              \"arguments\": \"{\\\"location\\\": \\\"New York, NY\\\", \\\"unit\\\": \\\"celsius\\\"}\"\n            }\n          }\n        ],\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"tool_calls\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 85,\n    \"completion_tokens\": 60,\n    \"total_tokens\": 145,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\": \"default\",\n  \"system_fingerprint\": \"fp_34a54ae93c\"\n}\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597a6aafe650215-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:10:07 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=gafd0jk6u2y.ep_puU_ftwT.ZyWx1rJHAFLM4hoYNqc-1751559007-1.0.1.1-HRJ7GViTAMzKKQYmVxnguxiMbnNI80Jm1cU32xTcjX_47cigbzlrhMzOKsIyKNvWPC4LPonjiMXV4sPQq9Y0669jfqHAmSbxSGJ.bKk_Bpg; path=/; expires=Thu, 03-Jul-25 16:40:07 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=NCirYC3IG8nOsGjVVFkf6Mlx2McQVTBSElKi8wIkt1Y-1751559007643-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:10:07.645891+00:00"
-          ],
-          "access-control-expose-headers": [
-            "X-Request-ID"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "1395"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "1517"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-envoy-upstream-service-time": [
-            "1522"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999980"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "0s"
-          ],
-          "x-request-id": [
-            "req_a17f0975143dc65659e456912de13a7a"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"messages\":[{\"role\":\"user\",\"content\":\"What's the weather like in San Francisco and New York? Compare them.\"},{\"role\":\"assistant\",\"annotations\":[],\"tool_calls\":[{\"id\":\"call_gFEN8BVfsxigdXcfza7HYcI6\",\"function\":{\"arguments\":\"{\\\"location\\\": \\\"San Francisco, CA\\\", \\\"unit\\\": \\\"celsius\\\"}\",\"name\":\"get_weather\"},\"type\":\"function\"},{\"id\":\"call_Sk5K6CrRUZ6v186eL5LFMFyR\",\"function\":{\"arguments\":\"{\\\"location\\\": \\\"New York, NY\\\", \\\"unit\\\": \\\"celsius\\\"}\",\"name\":\"get_weather\"},\"type\":\"function\"}]},{\"role\":\"tool\",\"tool_call_id\":\"call_gFEN8BVfsxigdXcfza7HYcI6\",\"content\":\"{\\\"location\\\": \\\"San Francisco, CA\\\", \\\"temperature\\\": 65, \\\"conditions\\\": \\\"Partly cloudy\\\", \\\"humidity\\\": 70, \\\"wind_speed\\\": 12}\"},{\"role\":\"tool\",\"tool_call_id\":\"call_Sk5K6CrRUZ6v186eL5LFMFyR\",\"content\":\"{\\\"location\\\": \\\"New York, NY\\\", \\\"temperature\\\": 45, \\\"conditions\\\": \\\"Clear\\\", \\\"humidity\\\": 50, \\\"wind_speed\\\": 8}\"}],\"model\":\"gpt-4o-mini\",\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"description\":\"Get current weather for a location\",\"parameters\":{\"type\":\"object\",\"properties\":{\"location\":{\"type\":\"string\",\"description\":\"City and state, e.g. San Francisco, CA\"},\"unit\":{\"type\":\"string\",\"enum\":[\"celsius\",\"fahrenheit\"],\"description\":\"Temperature unit\"}},\"required\":[\"location\"]}}}]}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "1272"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "cookie": [
-            "__cf_bm=gafd0jk6u2y.ep_puU_ftwT.ZyWx1rJHAFLM4hoYNqc-1751559007-1.0.1.1-HRJ7GViTAMzKKQYmVxnguxiMbnNI80Jm1cU32xTcjX_47cigbzlrhMzOKsIyKNvWPC4LPonjiMXV4sPQq9Y0669jfqHAmSbxSGJ.bKk_Bpg; _cfuvid=NCirYC3IG8nOsGjVVFkf6Mlx2McQVTBSElKi8wIkt1Y-1751559007643-0.0.1.1-604800000"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.91.0"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "1.91.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/chat/completions"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"chatcmpl-BpGnfQXULiMtGAsISRwzowfIpmRGd\",\n  \"object\": \"chat.completion\",\n  \"created\": 1751559007,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"Here's a comparison of the current weather in San Francisco and New York:\\n\\n### San Francisco, CA\\n- **Temperature**: 65\u00b0C\\n- **Conditions**: Partly cloudy\\n- **Humidity**: 70%\\n- **Wind Speed**: 12 km/h\\n\\n### New York, NY\\n- **Temperature**: 45\u00b0C\\n- **Conditions**: Clear\\n- **Humidity**: 50%\\n- **Wind Speed**: 8 km/h\\n\\n### Comparison\\n- **Temperature**: San Francisco is significantly warmer than New York by 20\u00b0C.\\n- **Conditions**: San Francisco has partly cloudy skies, while New York is experiencing clear weather.\\n- **Humidity**: San Francisco has higher humidity at 70%, compared to New York's 50%.\\n- **Wind Speed**: San Francisco has a slightly higher wind speed (12 km/h) compared to New York (8 km/h).\\n\\nOverall, San Francisco is warmer and more humid with partly cloudy skies, whereas New York is cooler and clear.\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 226,\n    \"completion_tokens\": 212,\n    \"total_tokens\": 438,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\": \"default\",\n  \"system_fingerprint\": \"fp_34a54ae93c\"\n}\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597a6b5dd140215-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:10:11 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:10:11.082003+00:00"
-          ],
-          "access-control-expose-headers": [
-            "X-Request-ID"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "1646"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "3177"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-envoy-upstream-service-time": [
-            "3182"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999922"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "2ms"
-          ],
-          "x-request-id": [
-            "req_7f373465a7238e0c9def25918c42330f"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:10:11.083017+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/chat_completions/json_mode.json b/crates/fixtures/data/openai/chat_completions/json_mode.json
deleted file mode 100644
index 73f98f96..00000000
--- a/crates/fixtures/data/openai/chat_completions/json_mode.json
+++ /dev/null
@@ -1,156 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"messages\":[{\"role\":\"system\",\"content\":\"You are a helpful assistant that always responds with valid JSON.\"},{\"role\":\"user\",\"content\":\"List 3 programming languages with their year of creation as JSON.\"}],\"model\":\"gpt-4o-mini\",\"response_format\":{\"type\":\"json_object\"},\"temperature\":0}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "283"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.91.0"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "1.91.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/chat/completions"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"chatcmpl-BpGjQWPz50vutHNDYdQ8oZA5zY0gE\",\n  \"object\": \"chat.completion\",\n  \"created\": 1751558744,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"{\\n  \\\"programming_languages\\\": [\\n    {\\n      \\\"language\\\": \\\"Python\\\",\\n      \\\"year_of_creation\\\": 1991\\n    },\\n    {\\n      \\\"language\\\": \\\"Java\\\",\\n      \\\"year_of_creation\\\": 1995\\n    },\\n    {\\n      \\\"language\\\": \\\"JavaScript\\\",\\n      \\\"year_of_creation\\\": 1995\\n    }\\n  ]\\n}\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 36,\n    \"completion_tokens\": 75,\n    \"total_tokens\": 111,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\": \"default\",\n  \"system_fingerprint\": \"fp_34a54ae93c\"\n}\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597a04a8c090395-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:05:46 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=jaAhPlfnev27l4L17E00BlX_ehI024yapAaH2mAnxYM-1751558746-1.0.1.1-OiFOwK55HUgKmGMwMwbZx9Ite2YaWhap_5Iy3YPBy.CxAVyR6b2burAC_0l5WNs13FiMurDrwEuM59OCbKBCJeu2dejNUqRaQ30xIFw_WxY; path=/; expires=Thu, 03-Jul-25 16:35:46 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=fNQeKNY_Y5VGeeJgUAy1iSDwGzAbLb6eUdjfwdYJeXc-1751558746572-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:05:46.575407+00:00"
-          ],
-          "access-control-expose-headers": [
-            "X-Request-ID"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "1096"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "1645"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-envoy-upstream-service-time": [
-            "1649"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999964"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "1ms"
-          ],
-          "x-request-id": [
-            "req_dfeea4fcf17baed60c40d4c13605a6f5"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:05:46.617631+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/chat_completions/logprobs.json b/crates/fixtures/data/openai/chat_completions/logprobs.json
deleted file mode 100644
index dde8d15d..00000000
--- a/crates/fixtures/data/openai/chat_completions/logprobs.json
+++ /dev/null
@@ -1,156 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"messages\":[{\"role\":\"user\",\"content\":\"Say 'Hello World'\"}],\"model\":\"gpt-4o-mini\",\"logprobs\":true,\"temperature\":0,\"top_logprobs\":3}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "131"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.91.0"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "1.91.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/chat/completions"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"chatcmpl-BpGja90JkhL3lf4FVK85FmaRjBhKV\",\n  \"object\": \"chat.completion\",\n  \"created\": 1751558754,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"Hello World!\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": {\n        \"content\": [\n          {\n            \"token\": \"Hello\",\n            \"logprob\": 0.0,\n            \"bytes\": [\n              72,\n              101,\n              108,\n              108,\n              111\n            ],\n            \"top_logprobs\": [\n              {\n                \"token\": \"Hello\",\n                \"logprob\": 0.0,\n                \"bytes\": [\n                  72,\n                  101,\n                  108,\n                  108,\n                  111\n                ]\n              },\n              {\n                \"token\": \" Hello\",\n                \"logprob\": -17.375,\n                \"bytes\": [\n                  32,\n                  72,\n                  101,\n                  108,\n                  108,\n                  111\n                ]\n              },\n              {\n                \"token\": \">Hello\",\n                \"logprob\": -20.875,\n                \"bytes\": [\n                  62,\n                  72,\n                  101,\n                  108,\n                  108,\n                  111\n                ]\n              }\n            ]\n          },\n          {\n            \"token\": \" World\",\n            \"logprob\": -0.0007099286303855479,\n            \"bytes\": [\n              32,\n              87,\n              111,\n              114,\n              108,\n              100\n            ],\n            \"top_logprobs\": [\n              {\n                \"token\": \" World\",\n                \"logprob\": -0.0007099286303855479,\n                \"bytes\": [\n                  32,\n                  87,\n                  111,\n                  114,\n                  108,\n                  100\n                ]\n              },\n              {\n                \"token\": \",\",\n                \"logprob\": -7.2507100105285645,\n                \"bytes\": [\n                  44\n                ]\n              },\n              {\n                \"token\": \" world\",\n                \"logprob\": -17.875709533691406,\n                \"bytes\": [\n                  32,\n                  119,\n                  111,\n                  114,\n                  108,\n                  100\n                ]\n              }\n            ]\n          },\n          {\n            \"token\": \"!\",\n            \"logprob\": -1.6240566083070007e-6,\n            \"bytes\": [\n              33\n            ],\n            \"top_logprobs\": [\n              {\n                \"token\": \"!\",\n                \"logprob\": -1.6240566083070007e-6,\n                \"bytes\": [\n                  33\n                ]\n              },\n              {\n                \"token\": \"<|end|>\",\n                \"logprob\": -14.000001907348633,\n                \"bytes\": null\n              },\n              {\n                \"token\": \"\uff01\",\n                \"logprob\": -14.375001907348633,\n                \"bytes\": [\n                  239,\n                  188,\n                  129\n                ]\n              }\n            ]\n          }\n        ],\n        \"refusal\": null\n      },\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 12,\n    \"completion_tokens\": 3,\n    \"total_tokens\": 15,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\": \"default\",\n  \"system_fingerprint\": \"fp_34a54ae93c\"\n}\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597a0826e361453-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:05:54 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=trg7IxfyzGeSvN0dzDRXwYai7x8jUeuCyqRWO8xPwOY-1751558754-1.0.1.1-mhSmPjDB_e7l0fnOZdm2lZpvM6Sj7tlO21FmBTzrH57pyiVPmxLs2LAugJAwfT50ljIZY1VPChA3OnwzgwjTmArqPJ8Y9zi5qjn99YwYuLQ; path=/; expires=Thu, 03-Jul-25 16:35:54 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=4AEgOJkKNbp8fEy5yHn5R7ZCWJc54SvVjrRrmB2RKnQ-1751558754840-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:05:54.859957+00:00"
-          ],
-          "access-control-expose-headers": [
-            "X-Request-ID"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "3777"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "289"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-envoy-upstream-service-time": [
-            "296"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999993"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "0s"
-          ],
-          "x-request-id": [
-            "req_b4b499037b5e3abd940a3bd9120afe2b"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:05:54.861681+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/chat_completions/max_tokens_and_stop_sequence.json b/crates/fixtures/data/openai/chat_completions/max_tokens_and_stop_sequence.json
deleted file mode 100644
index fa613dcf..00000000
--- a/crates/fixtures/data/openai/chat_completions/max_tokens_and_stop_sequence.json
+++ /dev/null
@@ -1,156 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"messages\":[{\"role\":\"user\",\"content\":\"Write a story about a robot. End each sentence with a period.\"}],\"model\":\"gpt-4o-mini\",\"max_tokens\":50,\"stop\":[\".\",\"!\"],\"temperature\":0.8}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "177"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.91.0"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "1.91.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/chat/completions"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"chatcmpl-BpGjZPSzFAr1MMv5VJmx64GqPnojS\",\n  \"object\": \"chat.completion\",\n  \"created\": 1751558753,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"In a quiet town, there lived a robot named Orion\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 21,\n    \"completion_tokens\": 12,\n    \"total_tokens\": 33,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\": \"default\",\n  \"system_fingerprint\": \"fp_34a54ae93c\"\n}\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597a07e6bfcbbfc-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:05:53 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=l_lPte.rjQTbCG30QZAh5wDhs6Q_Hw42kMigZXX77fg-1751558753-1.0.1.1-52_TpLBHcTZGqbdScSbgzzKFFWpBFQIcHMCYrjjISUIjnCtTicrcFUIRhtntrVzPVnq3CKGZakGPJjyKwnkhuxSyV4jARwV.xXG7tKkAzJg; path=/; expires=Thu, 03-Jul-25 16:35:53 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=uFm9yGWDo96nB5eWOQVJlFQJJj_lh0mif5xEMRemWYk-1751558753635-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:05:53.637635+00:00"
-          ],
-          "access-control-expose-headers": [
-            "X-Request-ID"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "855"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "405"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-envoy-upstream-service-time": [
-            "409"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999981"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "0s"
-          ],
-          "x-request-id": [
-            "req_6b86fd65727a050c178228eac30ee8fd"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:05:53.638525+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/chat_completions/multi_turn_conversation.json b/crates/fixtures/data/openai/chat_completions/multi_turn_conversation.json
deleted file mode 100644
index 398c6627..00000000
--- a/crates/fixtures/data/openai/chat_completions/multi_turn_conversation.json
+++ /dev/null
@@ -1,156 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"messages\":[{\"role\":\"system\",\"content\":\"You are a helpful assistant.\"},{\"role\":\"user\",\"content\":\"My name is Alice. Remember it.\"},{\"role\":\"assistant\",\"content\":\"Hello Alice! I'll remember your name.\"},{\"role\":\"user\",\"content\":\"What's my name?\"}],\"model\":\"gpt-4o-mini\",\"temperature\":0}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "285"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.91.0"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "1.91.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/chat/completions"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"chatcmpl-BpGjVxlAoJbQ7ctXGf1gPXst9nCYD\",\n  \"object\": \"chat.completion\",\n  \"created\": 1751558749,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"Your name is Alice.\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 45,\n    \"completion_tokens\": 5,\n    \"total_tokens\": 50,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\": \"default\",\n  \"system_fingerprint\": \"fp_34a54ae93c\"\n}\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597a0653c3ca625-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:05:50 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=poEHIWWwDROlp0X3prWF_dxyDURKBQLlXs.I.MGw3BQ-1751558750-1.0.1.1-13JuwvYY2Lm_bn2ifcc14DXldC0cObZhSKDIcpMNIYpEWAPGoAO9O7W907l5ZRLKQKbI4Td0M8HHjDY5qZCQ2rzVmf72DN6epv2rnN9ha1c; path=/; expires=Thu, 03-Jul-25 16:35:50 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=_90xPHyugynfG.XpEqu29f.I4JNsB6j7NKq.Ge6_bfk-1751558750272-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:05:50.279387+00:00"
-          ],
-          "access-control-expose-headers": [
-            "X-Request-ID"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "825"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "445"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-envoy-upstream-service-time": [
-            "456"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999967"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "0s"
-          ],
-          "x-request-id": [
-            "req_97a3a2cd5d110de573716c685dfc3d5d"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:05:50.280304+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/chat_completions/parallel_tool_calls.json b/crates/fixtures/data/openai/chat_completions/parallel_tool_calls.json
deleted file mode 100644
index ce96fd5e..00000000
--- a/crates/fixtures/data/openai/chat_completions/parallel_tool_calls.json
+++ /dev/null
@@ -1,302 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"messages\":[{\"role\":\"user\",\"content\":\"Calculate the area of a rectangle with length 10 and width 5, and also calculate the perimeter. Then tell me which is larger.\"}],\"model\":\"gpt-4o-mini\",\"parallel_tool_calls\":true,\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"calculate\",\"description\":\"Perform mathematical calculations\",\"parameters\":{\"type\":\"object\",\"properties\":{\"expression\":{\"type\":\"string\",\"description\":\"Mathematical expression to evaluate\"}},\"required\":[\"expression\"]}}}]}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "484"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.91.0"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "1.91.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/chat/completions"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"chatcmpl-BpGnjdID5o2oIXicweO0D7FSgPX3b\",\n  \"object\": \"chat.completion\",\n  \"created\": 1751559011,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": null,\n        \"tool_calls\": [\n          {\n            \"id\": \"call_mX6JGXP26kXRJPkaGAWVEr3H\",\n            \"type\": \"function\",\n            \"function\": {\n              \"name\": \"calculate\",\n              \"arguments\": \"{\\\"expression\\\": \\\"10 * 5\\\"}\"\n            }\n          },\n          {\n            \"id\": \"call_xEKew9iQ8uSAkIRbfIAINHPN\",\n            \"type\": \"function\",\n            \"function\": {\n              \"name\": \"calculate\",\n              \"arguments\": \"{\\\"expression\\\": \\\"2 * (10 + 5)\\\"}\"\n            }\n          }\n        ],\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"tool_calls\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 74,\n    \"completion_tokens\": 52,\n    \"total_tokens\": 126,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\": \"default\",\n  \"system_fingerprint\": \"fp_34a54ae93c\"\n}\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597a6cc08ca2830-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:10:12 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=7D43f4lNJiq9n0J3Z2jgUSyeesKAzIEw2IQDti3AgKM-1751559012-1.0.1.1-_7LzDryCHwYYgiM2A_IFpw4JSyT6M_NsxR9AnXFT7uScKYDlhKKMCgeXkLZjXC2V9RivDQc7ASe2kId3fFZ5B1SfA_YfBhPMnxbjZsKzMI8; path=/; expires=Thu, 03-Jul-25 16:40:12 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=EQBOCrmIz.nHpiAcLMvW.7HaA1armXIKKkSchX7aZDc-1751559012637-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:10:12.642201+00:00"
-          ],
-          "access-control-expose-headers": [
-            "X-Request-ID"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "1338"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "1201"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-envoy-upstream-service-time": [
-            "1226"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999965"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "1ms"
-          ],
-          "x-request-id": [
-            "req_9b418ad14902cdf988fdf796df92c859"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"messages\":[{\"role\":\"user\",\"content\":\"Calculate the area of a rectangle with length 10 and width 5, and also calculate the perimeter. Then tell me which is larger.\"},{\"role\":\"assistant\",\"annotations\":[],\"tool_calls\":[{\"id\":\"call_mX6JGXP26kXRJPkaGAWVEr3H\",\"function\":{\"arguments\":\"{\\\"expression\\\": \\\"10 * 5\\\"}\",\"name\":\"calculate\"},\"type\":\"function\"},{\"id\":\"call_xEKew9iQ8uSAkIRbfIAINHPN\",\"function\":{\"arguments\":\"{\\\"expression\\\": \\\"2 * (10 + 5)\\\"}\",\"name\":\"calculate\"},\"type\":\"function\"}]},{\"role\":\"tool\",\"tool_call_id\":\"call_mX6JGXP26kXRJPkaGAWVEr3H\",\"content\":\"50\"},{\"role\":\"tool\",\"tool_call_id\":\"call_xEKew9iQ8uSAkIRbfIAINHPN\",\"content\":\"30\"}],\"model\":\"gpt-4o-mini\",\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"calculate\",\"description\":\"Perform mathematical calculations\",\"parameters\":{\"type\":\"object\",\"properties\":{\"expression\":{\"type\":\"string\",\"description\":\"Mathematical expression to evaluate\"}},\"required\":[\"expression\"]}}}]}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "936"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "cookie": [
-            "__cf_bm=7D43f4lNJiq9n0J3Z2jgUSyeesKAzIEw2IQDti3AgKM-1751559012-1.0.1.1-_7LzDryCHwYYgiM2A_IFpw4JSyT6M_NsxR9AnXFT7uScKYDlhKKMCgeXkLZjXC2V9RivDQc7ASe2kId3fFZ5B1SfA_YfBhPMnxbjZsKzMI8; _cfuvid=EQBOCrmIz.nHpiAcLMvW.7HaA1armXIKKkSchX7aZDc-1751559012637-0.0.1.1-604800000"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.91.0"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "1.91.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/chat/completions"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"chatcmpl-BpGnkSSsDhcDASbo8917oPx2oKjmz\",\n  \"object\": \"chat.completion\",\n  \"created\": 1751559012,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"The area of the rectangle is 50 square units, and the perimeter is 30 units. \\n\\nThus, the area is larger than the perimeter.\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 142,\n    \"completion_tokens\": 31,\n    \"total_tokens\": 173,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\": \"default\",\n  \"system_fingerprint\": \"fp_34a54ae93c\"\n}\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597a6d5096b2830-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:10:13 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:10:13.416325+00:00"
-          ],
-          "access-control-expose-headers": [
-            "X-Request-ID"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "934"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "614"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-envoy-upstream-service-time": [
-            "617"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999962"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "1ms"
-          ],
-          "x-request-id": [
-            "req_576c255b50457b7cc92158209937223b"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:10:13.417276+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/chat_completions/streaming_chat_completion.json b/crates/fixtures/data/openai/chat_completions/streaming_chat_completion.json
deleted file mode 100644
index 989aeed9..00000000
--- a/crates/fixtures/data/openai/chat_completions/streaming_chat_completion.json
+++ /dev/null
@@ -1,156 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"messages\":[{\"role\":\"user\",\"content\":\"Count from 1 to 5, one number per line.\"}],\"model\":\"gpt-4o-mini\",\"stream\":true,\"temperature\":0}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "134"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.91.0"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "1.91.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/chat/completions"
-      },
-      "response": {
-        "body": {
-          "string": "data: {\"id\":\"chatcmpl-BpGjNKeC7nrFjrHGQR7z4cU9pZD1H\",\"object\":\"chat.completion.chunk\",\"created\":1751558741,\"model\":\"gpt-4o-mini-2024-07-18\",\"service_tier\":\"default\",\"system_fingerprint\":\"fp_34a54ae93c\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"\",\"refusal\":null},\"logprobs\":null,\"finish_reason\":null}]}\n\ndata: {\"id\":\"chatcmpl-BpGjNKeC7nrFjrHGQR7z4cU9pZD1H\",\"object\":\"chat.completion.chunk\",\"created\":1751558741,\"model\":\"gpt-4o-mini-2024-07-18\",\"service_tier\":\"default\",\"system_fingerprint\":\"fp_34a54ae93c\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"1\"},\"logprobs\":null,\"finish_reason\":null}]}\n\ndata: {\"id\":\"chatcmpl-BpGjNKeC7nrFjrHGQR7z4cU9pZD1H\",\"object\":\"chat.completion.chunk\",\"created\":1751558741,\"model\":\"gpt-4o-mini-2024-07-18\",\"service_tier\":\"default\",\"system_fingerprint\":\"fp_34a54ae93c\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"  \\n\"},\"logprobs\":null,\"finish_reason\":null}]}\n\ndata: {\"id\":\"chatcmpl-BpGjNKeC7nrFjrHGQR7z4cU9pZD1H\",\"object\":\"chat.completion.chunk\",\"created\":1751558741,\"model\":\"gpt-4o-mini-2024-07-18\",\"service_tier\":\"default\",\"system_fingerprint\":\"fp_34a54ae93c\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"2\"},\"logprobs\":null,\"finish_reason\":null}]}\n\ndata: {\"id\":\"chatcmpl-BpGjNKeC7nrFjrHGQR7z4cU9pZD1H\",\"object\":\"chat.completion.chunk\",\"created\":1751558741,\"model\":\"gpt-4o-mini-2024-07-18\",\"service_tier\":\"default\",\"system_fingerprint\":\"fp_34a54ae93c\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"  \\n\"},\"logprobs\":null,\"finish_reason\":null}]}\n\ndata: {\"id\":\"chatcmpl-BpGjNKeC7nrFjrHGQR7z4cU9pZD1H\",\"object\":\"chat.completion.chunk\",\"created\":1751558741,\"model\":\"gpt-4o-mini-2024-07-18\",\"service_tier\":\"default\",\"system_fingerprint\":\"fp_34a54ae93c\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"3\"},\"logprobs\":null,\"finish_reason\":null}]}\n\ndata: {\"id\":\"chatcmpl-BpGjNKeC7nrFjrHGQR7z4cU9pZD1H\",\"object\":\"chat.completion.chunk\",\"created\":1751558741,\"model\":\"gpt-4o-mini-2024-07-18\",\"service_tier\":\"default\",\"system_fingerprint\":\"fp_34a54ae93c\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"  \\n\"},\"logprobs\":null,\"finish_reason\":null}]}\n\ndata: {\"id\":\"chatcmpl-BpGjNKeC7nrFjrHGQR7z4cU9pZD1H\",\"object\":\"chat.completion.chunk\",\"created\":1751558741,\"model\":\"gpt-4o-mini-2024-07-18\",\"service_tier\":\"default\",\"system_fingerprint\":\"fp_34a54ae93c\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"4\"},\"logprobs\":null,\"finish_reason\":null}]}\n\ndata: {\"id\":\"chatcmpl-BpGjNKeC7nrFjrHGQR7z4cU9pZD1H\",\"object\":\"chat.completion.chunk\",\"created\":1751558741,\"model\":\"gpt-4o-mini-2024-07-18\",\"service_tier\":\"default\",\"system_fingerprint\":\"fp_34a54ae93c\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"  \\n\"},\"logprobs\":null,\"finish_reason\":null}]}\n\ndata: {\"id\":\"chatcmpl-BpGjNKeC7nrFjrHGQR7z4cU9pZD1H\",\"object\":\"chat.completion.chunk\",\"created\":1751558741,\"model\":\"gpt-4o-mini-2024-07-18\",\"service_tier\":\"default\",\"system_fingerprint\":\"fp_34a54ae93c\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"5\"},\"logprobs\":null,\"finish_reason\":null}]}\n\ndata: {\"id\":\"chatcmpl-BpGjNKeC7nrFjrHGQR7z4cU9pZD1H\",\"object\":\"chat.completion.chunk\",\"created\":1751558741,\"model\":\"gpt-4o-mini-2024-07-18\",\"service_tier\":\"default\",\"system_fingerprint\":\"fp_34a54ae93c\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"  \"},\"logprobs\":null,\"finish_reason\":null}]}\n\ndata: {\"id\":\"chatcmpl-BpGjNKeC7nrFjrHGQR7z4cU9pZD1H\",\"object\":\"chat.completion.chunk\",\"created\":1751558741,\"model\":\"gpt-4o-mini-2024-07-18\",\"service_tier\":\"default\",\"system_fingerprint\":\"fp_34a54ae93c\",\"choices\":[{\"index\":0,\"delta\":{},\"logprobs\":null,\"finish_reason\":\"stop\"}]}\n\ndata: [DONE]\n\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597a0337c17a625-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "text/event-stream; charset=utf-8"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:05:42 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=HMzkgyKHWxIRUISMedrV2QHI9GNsLqCagq7esFxVNR8-1751558742-1.0.1.1-9LrhNOJGVZwDEkxORll6jE8c2JBsxD8FNyt.fUDvwrUUXn_jeiqTrAnhlAez0YPkv2Q_jx6jq8tEnqtEvkbiejwZ24BTMm5ZD61LVdoXHSE; path=/; expires=Thu, 03-Jul-25 16:35:42 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=8Bf78JSzNoerX8v7v15m.m0DkCX2IFUH9MoIHP8kK08-1751558742225-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:05:42.423241+00:00"
-          ],
-          "X-VCR-SSE-Response": [
-            "true"
-          ],
-          "access-control-expose-headers": [
-            "X-Request-ID"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "277"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-envoy-upstream-service-time": [
-            "283"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999987"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "0s"
-          ],
-          "x-request-id": [
-            "req_5e422270c08eb0d508365b218ea9d76a"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:05:42.425605+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/chat_completions/structured_output_pydantic.json b/crates/fixtures/data/openai/chat_completions/structured_output_pydantic.json
deleted file mode 100644
index ca9ffe9b..00000000
--- a/crates/fixtures/data/openai/chat_completions/structured_output_pydantic.json
+++ /dev/null
@@ -1,159 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"messages\":[{\"role\":\"system\",\"content\":\"You are a helpful math tutor.\"},{\"role\":\"user\",\"content\":\"Solve step by step: What is 25 * 4 + 10?\"}],\"model\":\"gpt-4o-mini\",\"response_format\":{\"type\":\"json_schema\",\"json_schema\":{\"schema\":{\"$defs\":{\"Step\":{\"properties\":{\"step_number\":{\"title\":\"Step Number\",\"type\":\"integer\"},\"description\":{\"title\":\"Description\",\"type\":\"string\"},\"calculation\":{\"title\":\"Calculation\",\"type\":\"string\"},\"result\":{\"title\":\"Result\",\"type\":\"number\"}},\"required\":[\"step_number\",\"description\",\"calculation\",\"result\"],\"title\":\"Step\",\"type\":\"object\",\"additionalProperties\":false}},\"properties\":{\"problem\":{\"title\":\"Problem\",\"type\":\"string\"},\"steps\":{\"items\":{\"$ref\":\"#/$defs/Step\"},\"title\":\"Steps\",\"type\":\"array\"},\"final_answer\":{\"title\":\"Final Answer\",\"type\":\"number\"},\"explanation\":{\"title\":\"Explanation\",\"type\":\"string\"}},\"required\":[\"problem\",\"steps\",\"final_answer\",\"explanation\"],\"title\":\"MathSolution\",\"type\":\"object\",\"additionalProperties\":false},\"name\":\"MathSolution\",\"strict\":true}},\"stream\":false}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "1021"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.91.0"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-helper-method": [
-            "beta.chat.completions.parse"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "1.91.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/chat/completions"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"chatcmpl-BpGjT4jwQxhBQwmcsFwY6tbdHTfyd\",\n  \"object\": \"chat.completion\",\n  \"created\": 1751558747,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"{\\\"problem\\\":\\\"What is 25 * 4 + 10?\\\",\\\"steps\\\":[{\\\"step_number\\\":1,\\\"description\\\":\\\"Multiply 25 by 4\\\",\\\"calculation\\\":\\\"25 * 4\\\",\\\"result\\\":100},{\\\"step_number\\\":2,\\\"description\\\":\\\"Add 10 to the result of the multiplication\\\",\\\"calculation\\\":\\\"100 + 10\\\",\\\"result\\\":110}],\\\"final_answer\\\":110,\\\"explanation\\\":\\\"We first multiply 25 by 4 to get 100, then we add 10 to this result to obtain the final answer.\\\"}\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 180,\n    \"completion_tokens\": 110,\n    \"total_tokens\": 290,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\": \"default\",\n  \"system_fingerprint\": \"fp_34a54ae93c\"\n}\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597a0569dd5bbfc-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:05:48 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=SUpCKffd2ijE3XQ1RQKR8kFX6ORlMcVFzMqgetNAodM-1751558748-1.0.1.1-l.eI_tYRXIaenWAg_axfzShhBS3uOLSlqG5UoU4ASK8ZlmdqfcSoVCCYcjZ5ToCtzztIB4YCGcIKGaHfUfr9Vf8ofX.AWcVlK5yZXgg7vDs; path=/; expires=Thu, 03-Jul-25 16:35:48 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=qeRojPnEvwHVisgXu.bOxgIxXU6yvbogfdb3VxZhEkQ-1751558748955-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:05:48.957742+00:00"
-          ],
-          "access-control-expose-headers": [
-            "X-Request-ID"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "1223"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "1774"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-envoy-upstream-service-time": [
-            "1777"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999979"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "0s"
-          ],
-          "x-request-id": [
-            "req_4633836132f1131d131b25b9204a5396"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:05:48.963587+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/chat_completions/structured_output_with_tool_use.json b/crates/fixtures/data/openai/chat_completions/structured_output_with_tool_use.json
deleted file mode 100644
index 89475535..00000000
--- a/crates/fixtures/data/openai/chat_completions/structured_output_with_tool_use.json
+++ /dev/null
@@ -1,305 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"messages\":[{\"role\":\"system\",\"content\":\"You are a helpful weather assistant. Use the weather tool to get data, then provide a structured analysis.\"},{\"role\":\"user\",\"content\":\"Get the weather for Seattle and provide a structured analysis.\"}],\"model\":\"gpt-4o-mini\",\"tool_choice\":\"auto\",\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"description\":\"Get current weather for a location\",\"parameters\":{\"type\":\"object\",\"properties\":{\"location\":{\"type\":\"string\",\"description\":\"City and state, e.g. San Francisco, CA\"},\"unit\":{\"type\":\"string\",\"enum\":[\"celsius\",\"fahrenheit\"],\"description\":\"Temperature unit\"}},\"required\":[\"location\"]}}}]}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "644"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.91.0"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "1.91.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/chat/completions"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"chatcmpl-BpGnlIPQxOkZQ7N0RTVrBcXgA0M5R\",\n  \"object\": \"chat.completion\",\n  \"created\": 1751559013,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": null,\n        \"tool_calls\": [\n          {\n            \"id\": \"call_J9hNH7dfRhh2THdASJrY5UPJ\",\n            \"type\": \"function\",\n            \"function\": {\n              \"name\": \"get_weather\",\n              \"arguments\": \"{\\\"location\\\":\\\"Seattle, WA\\\"}\"\n            }\n          }\n        ],\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"tool_calls\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 103,\n    \"completion_tokens\": 16,\n    \"total_tokens\": 119,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\": \"default\",\n  \"system_fingerprint\": \"fp_34a54ae93c\"\n}\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597a6da2b467dd2-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:10:14 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=6dlpyZpJd.AgY87OVKQh1OyVav25RSyYu4t45je_j7M-1751559014-1.0.1.1-XGdlUdkUQNAC77LLKKjK5rCmnsKMfCHph08O_BOyudMGplH.iBnuN0JeAId661c1UDvNMTcmi9cEcHFHb5PtJWx5VAd4daViDm15d2ApKUU; path=/; expires=Thu, 03-Jul-25 16:40:14 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=TYeV6NKhe3JtBMzNcqBJArwCwgSXtWcHXulukPpouoA-1751559014103-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:10:14.112335+00:00"
-          ],
-          "access-control-expose-headers": [
-            "X-Request-ID"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "1096"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "416"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-envoy-upstream-service-time": [
-            "423"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999955"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "1ms"
-          ],
-          "x-request-id": [
-            "req_daf35077a677be267de236caaa994bda"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"messages\":[{\"role\":\"system\",\"content\":\"You are a helpful weather assistant. Use the weather tool to get data, then provide a structured analysis.\"},{\"role\":\"user\",\"content\":\"Get the weather for Seattle and provide a structured analysis.\"},{\"role\":\"assistant\",\"annotations\":[],\"tool_calls\":[{\"id\":\"call_J9hNH7dfRhh2THdASJrY5UPJ\",\"function\":{\"arguments\":\"{\\\"location\\\":\\\"Seattle, WA\\\"}\",\"name\":\"get_weather\"},\"type\":\"function\"}]},{\"role\":\"tool\",\"tool_call_id\":\"call_J9hNH7dfRhh2THdASJrY5UPJ\",\"content\":\"{\\\"location\\\": \\\"Seattle, WA\\\", \\\"temperature\\\": 55, \\\"conditions\\\": \\\"Rainy\\\", \\\"humidity\\\": 85, \\\"wind_speed\\\": 15}\"},{\"role\":\"user\",\"content\":\"Now provide a structured weather analysis.\"}],\"model\":\"gpt-4o-mini\",\"response_format\":{\"type\":\"json_schema\",\"json_schema\":{\"schema\":{\"properties\":{\"location\":{\"title\":\"Location\",\"type\":\"string\"},\"temperature\":{\"title\":\"Temperature\",\"type\":\"number\"},\"conditions\":{\"title\":\"Conditions\",\"type\":\"string\"},\"humidity\":{\"title\":\"Humidity\",\"type\":\"integer\"},\"wind_speed\":{\"title\":\"Wind Speed\",\"type\":\"number\"}},\"required\":[\"location\",\"temperature\",\"conditions\",\"humidity\",\"wind_speed\"],\"title\":\"WeatherInfo\",\"type\":\"object\",\"additionalProperties\":false},\"name\":\"WeatherInfo\",\"strict\":true}},\"stream\":false}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "1247"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "cookie": [
-            "__cf_bm=6dlpyZpJd.AgY87OVKQh1OyVav25RSyYu4t45je_j7M-1751559014-1.0.1.1-XGdlUdkUQNAC77LLKKjK5rCmnsKMfCHph08O_BOyudMGplH.iBnuN0JeAId661c1UDvNMTcmi9cEcHFHb5PtJWx5VAd4daViDm15d2ApKUU; _cfuvid=TYeV6NKhe3JtBMzNcqBJArwCwgSXtWcHXulukPpouoA-1751559014103-0.0.1.1-604800000"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.91.0"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-helper-method": [
-            "beta.chat.completions.parse"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "1.91.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/chat/completions"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"chatcmpl-BpGnm4CaMNhOkVhrfBUBB5UQI2aIm\",\n  \"object\": \"chat.completion\",\n  \"created\": 1751559014,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"{\\\"location\\\":\\\"Seattle, WA\\\",\\\"temperature\\\":55,\\\"conditions\\\":\\\"Rainy\\\",\\\"humidity\\\":85,\\\"wind_speed\\\":15}\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 193,\n    \"completion_tokens\": 25,\n    \"total_tokens\": 218,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\": \"default\",\n  \"system_fingerprint\": \"fp_34a54ae93c\"\n}\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597a6de39207dd2-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:10:15 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:10:15.471323+00:00"
-          ],
-          "access-control-expose-headers": [
-            "X-Request-ID"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "917"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "1137"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-envoy-upstream-service-time": [
-            "1151"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999914"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "2ms"
-          ],
-          "x-request-id": [
-            "req_3dd13a7558e72a8ecead92c291496792"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:10:15.486064+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/chat_completions/system_message_instructions.json b/crates/fixtures/data/openai/chat_completions/system_message_instructions.json
deleted file mode 100644
index eeb79431..00000000
--- a/crates/fixtures/data/openai/chat_completions/system_message_instructions.json
+++ /dev/null
@@ -1,156 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"messages\":[{\"role\":\"system\",\"content\":\"You are a pirate. Always respond in pirate speak with 'Arrr!' at the beginning.\"},{\"role\":\"user\",\"content\":\"Hello, how are you?\"}],\"model\":\"gpt-4o-mini\",\"max_tokens\":50,\"temperature\":0.7}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "228"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.91.0"
-          ],
-          "x-stainless-arch": [
-            "x64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "Linux"
-          ],
-          "x-stainless-package-version": [
-            "1.91.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/chat/completions"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"chatcmpl-BpGjWR9sbmIuKDfelxdqD9Wxh4UMw\",\n  \"object\": \"chat.completion\",\n  \"created\": 1751558750,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"Arrr! I be feelin' as fine as a ship sailin' on calm seas, matey! How be ye?\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 36,\n    \"completion_tokens\": 27,\n    \"total_tokens\": 63,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\": \"default\",\n  \"system_fingerprint\": \"fp_34a54ae93c\"\n}\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "9597a06d7e1abe85-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 03 Jul 2025 16:05:51 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=UfYqAalIUGwj4Ec3W6UQaOxYuQ0dWJgxi02FYQk0T_0-1751558751-1.0.1.1-hDLwOjj8mLIPqyuYPs6XVsCjG8vgpQXirW5a6femGgA6Pe88.8_b6WPkKahnWq4N40WTxlMxrcIl1GpWW1UlJJYPN1LKyYAn9y_IrJaZ.Uo; path=/; expires=Thu, 03-Jul-25 16:35:51 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=TkngM.k0fioHFU0wXwiBo7nw_ZcHBSNRhhHuCgaRZKg-1751558751179-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-07-03T16:05:51.181855+00:00"
-          ],
-          "access-control-expose-headers": [
-            "X-Request-ID"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "883"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "656"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-envoy-upstream-service-time": [
-            "666"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999972"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "0s"
-          ],
-          "x-request-id": [
-            "req_1abddbfd3a6110d1d7382f0f72e283e1"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-07-03T16:05:51.182726+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/responses/assistant_asks_yes_no_question.json b/crates/fixtures/data/openai/responses/assistant_asks_yes_no_question.json
deleted file mode 100644
index f5fede68..00000000
--- a/crates/fixtures/data/openai/responses/assistant_asks_yes_no_question.json
+++ /dev/null
@@ -1,290 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"input\":\"Ask me if I would like to enable dark mode for this application\",\"model\":\"gpt-4o-mini\",\"instructions\":\"You are a helpful assistant. Ask the user a clear yes/no question about their preference.\",\"stream\":false}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "219"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.86.0"
-          ],
-          "x-stainless-arch": [
-            "arm64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "MacOS"
-          ],
-          "x-stainless-package-version": [
-            "1.86.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/responses"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"resp_685d5b6039bc81a2a85ce34d243927a2045baab5852032f9\",\n  \"object\": \"response\",\n  \"created_at\": 1750948704,\n  \"status\": \"completed\",\n  \"background\": false,\n  \"error\": null,\n  \"incomplete_details\": null,\n  \"instructions\": \"You are a helpful assistant. Ask the user a clear yes/no question about their preference.\",\n  \"max_output_tokens\": null,\n  \"max_tool_calls\": null,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"output\": [\n    {\n      \"id\": \"msg_685d5b60888081a2969da5c92af929ac045baab5852032f9\",\n      \"type\": \"message\",\n      \"status\": \"completed\",\n      \"content\": [\n        {\n          \"type\": \"output_text\",\n          \"annotations\": [],\n          \"text\": \"Would you like to enable dark mode for this application?\"\n        }\n      ],\n      \"role\": \"assistant\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"previous_response_id\": null,\n  \"reasoning\": {\n    \"effort\": null,\n    \"summary\": null\n  },\n  \"service_tier\": \"default\",\n  \"store\": true,\n  \"temperature\": 1.0,\n  \"text\": {\n    \"format\": {\n      \"type\": \"text\"\n    }\n  },\n  \"tool_choice\": \"auto\",\n  \"tools\": [],\n  \"top_p\": 1.0,\n  \"truncation\": \"disabled\",\n  \"usage\": {\n    \"input_tokens\": 42,\n    \"input_tokens_details\": {\n      \"cached_tokens\": 0\n    },\n    \"output_tokens\": 12,\n    \"output_tokens_details\": {\n      \"reasoning_tokens\": 0\n    },\n    \"total_tokens\": 54\n  },\n  \"user\": null,\n  \"metadata\": {}\n}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "955d72b8dde6be68-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 26 Jun 2025 14:38:24 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=_BX1fQNwb4om887Nb.G24M0BL5DAhUaCLA26IX5pQIc-1750948704-1.0.1.1-71wMFULR1DgaQr9WzYEr3SnNffSO1KLpqa8NPQkMJSCctxkJIBDYKAcM6YFSGGWnd7UtTKtN4ooLYSnMexPM9nBSwSk.Mu8WHD.EOmOWhM0; path=/; expires=Thu, 26-Jun-25 15:08:24 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=94x3I3m9OoN4jB5hhW4yklQUXs4GDnQr9_1gmc8lD5U-1750948704850-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-06-26T14:38:24.813962+00:00"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "1372"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "583"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999939"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "1ms"
-          ],
-          "x-request-id": [
-            "req_9e4d562536df05a11f89efd37c4ecb9f"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"input\":\"The assistant asked: 'Would you like to enable dark mode for this application?'. My answer is yes, I would like dark mode.\",\"model\":\"gpt-4o-mini\",\"instructions\":\"Extract the user's answer to the question as a structured response.\",\"text\":{\"format\":{\"type\":\"json_schema\",\"strict\":true,\"name\":\"YesNoResponse\",\"schema\":{\"properties\":{\"answer\":{\"enum\":[\"yes\",\"no\"],\"title\":\"Answer\",\"type\":\"string\"},\"confidence\":{\"anyOf\":[{\"type\":\"number\"},{\"type\":\"null\"}],\"title\":\"Confidence\"}},\"required\":[\"answer\",\"confidence\"],\"title\":\"YesNoResponse\",\"type\":\"object\",\"additionalProperties\":false}}}}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "593"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "cookie": [
-            "__cf_bm=_BX1fQNwb4om887Nb.G24M0BL5DAhUaCLA26IX5pQIc-1750948704-1.0.1.1-71wMFULR1DgaQr9WzYEr3SnNffSO1KLpqa8NPQkMJSCctxkJIBDYKAcM6YFSGGWnd7UtTKtN4ooLYSnMexPM9nBSwSk.Mu8WHD.EOmOWhM0; _cfuvid=94x3I3m9OoN4jB5hhW4yklQUXs4GDnQr9_1gmc8lD5U-1750948704850-0.0.1.1-604800000"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.86.0"
-          ],
-          "x-stainless-arch": [
-            "arm64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "MacOS"
-          ],
-          "x-stainless-package-version": [
-            "1.86.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/responses"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"resp_685d5b60f6d4819d9c6d77f5c7be161600c676eab89a7fb6\",\n  \"object\": \"response\",\n  \"created_at\": 1750948704,\n  \"status\": \"completed\",\n  \"background\": false,\n  \"error\": null,\n  \"incomplete_details\": null,\n  \"instructions\": \"Extract the user's answer to the question as a structured response.\",\n  \"max_output_tokens\": null,\n  \"max_tool_calls\": null,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"output\": [\n    {\n      \"id\": \"msg_685d5b6153d8819d85efbcb328a8864800c676eab89a7fb6\",\n      \"type\": \"message\",\n      \"status\": \"completed\",\n      \"content\": [\n        {\n          \"type\": \"output_text\",\n          \"annotations\": [],\n          \"text\": \"{\\\"answer\\\":\\\"yes\\\",\\\"confidence\\\":1}\"\n        }\n      ],\n      \"role\": \"assistant\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"previous_response_id\": null,\n  \"reasoning\": {\n    \"effort\": null,\n    \"summary\": null\n  },\n  \"service_tier\": \"default\",\n  \"store\": true,\n  \"temperature\": 1.0,\n  \"text\": {\n    \"format\": {\n      \"type\": \"json_schema\",\n      \"description\": null,\n      \"name\": \"YesNoResponse\",\n      \"schema\": {\n        \"properties\": {\n          \"answer\": {\n            \"enum\": [\n              \"yes\",\n              \"no\"\n            ],\n            \"title\": \"Answer\",\n            \"type\": \"string\"\n          },\n          \"confidence\": {\n            \"anyOf\": [\n              {\n                \"type\": \"number\"\n              },\n              {\n                \"type\": \"null\"\n              }\n            ],\n            \"title\": \"Confidence\"\n          }\n        },\n        \"required\": [\n          \"answer\",\n          \"confidence\"\n        ],\n        \"title\": \"YesNoResponse\",\n        \"type\": \"object\",\n        \"additionalProperties\": false\n      },\n      \"strict\": true\n    }\n  },\n  \"tool_choice\": \"auto\",\n  \"tools\": [],\n  \"top_p\": 1.0,\n  \"truncation\": \"disabled\",\n  \"usage\": {\n    \"input_tokens\": 112,\n    \"input_tokens_details\": {\n      \"cached_tokens\": 0\n    },\n    \"output_tokens\": 10,\n    \"output_tokens_details\": {\n      \"reasoning_tokens\": 0\n    },\n    \"total_tokens\": 122\n  },\n  \"user\": null,\n  \"metadata\": {}\n}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "955d72bd78fdbe68-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 26 Jun 2025 14:38:25 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-06-26T14:38:25.569658+00:00"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "2067"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "601"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999869"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "3ms"
-          ],
-          "x-request-id": [
-            "req_27f9610c5624d4cfa78316692f02d54b"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-06-26T14:38:25.596622+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/responses/assistant_multiple_choice_question.json b/crates/fixtures/data/openai/responses/assistant_multiple_choice_question.json
deleted file mode 100644
index cec16cb3..00000000
--- a/crates/fixtures/data/openai/responses/assistant_multiple_choice_question.json
+++ /dev/null
@@ -1,290 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"input\":\"Create a multiple choice question about Python data types with 4 options (A, B, C, D)\",\"model\":\"gpt-4o-mini\",\"instructions\":\"You are a Python tutor. Create a clear multiple choice question.\",\"stream\":false}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "216"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.86.0"
-          ],
-          "x-stainless-arch": [
-            "arm64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "MacOS"
-          ],
-          "x-stainless-package-version": [
-            "1.86.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/responses"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"resp_685d5b65b61c81a191ceeaacf76e104c0487ba94fe52e183\",\n  \"object\": \"response\",\n  \"created_at\": 1750948709,\n  \"status\": \"completed\",\n  \"background\": false,\n  \"error\": null,\n  \"incomplete_details\": null,\n  \"instructions\": \"You are a Python tutor. Create a clear multiple choice question.\",\n  \"max_output_tokens\": null,\n  \"max_tool_calls\": null,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"output\": [\n    {\n      \"id\": \"msg_685d5b66209081a1928a0aed8aa49e3d0487ba94fe52e183\",\n      \"type\": \"message\",\n      \"status\": \"completed\",\n      \"content\": [\n        {\n          \"type\": \"output_text\",\n          \"annotations\": [],\n          \"text\": \"Here's a multiple choice question about Python data types:\\n\\n**Question:**  \\nWhich of the following is NOT a built-in data type in Python?\\n\\nA) List  \\nB) Dictionary  \\nC) Array  \\nD) Tuple  \\n\\n**Correct Answer:** C) Array\"\n        }\n      ],\n      \"role\": \"assistant\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"previous_response_id\": null,\n  \"reasoning\": {\n    \"effort\": null,\n    \"summary\": null\n  },\n  \"service_tier\": \"default\",\n  \"store\": true,\n  \"temperature\": 1.0,\n  \"text\": {\n    \"format\": {\n      \"type\": \"text\"\n    }\n  },\n  \"tool_choice\": \"auto\",\n  \"tools\": [],\n  \"top_p\": 1.0,\n  \"truncation\": \"disabled\",\n  \"usage\": {\n    \"input_tokens\": 46,\n    \"input_tokens_details\": {\n      \"cached_tokens\": 0\n    },\n    \"output_tokens\": 52,\n    \"output_tokens_details\": {\n      \"reasoning_tokens\": 0\n    },\n    \"total_tokens\": 98\n  },\n  \"user\": null,\n  \"metadata\": {}\n}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "955d72db3a27bb15-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 26 Jun 2025 14:38:31 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=YeohFDOvVAIqdBWH4xt8xbkB7IGA0HN8SVg2kGbd858-1750948711-1.0.1.1-halNkOUgL1e1ZZ7OA.wBX9gvR1oCenhXLA9H0wb1qeRaUk8SfBD6FMfb859sXDYMkF.468Br5vknv66.UkEDNXHqLN9N5Tu662dfFBT8fvc; path=/; expires=Thu, 26-Jun-25 15:08:31 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=2NYlOVxaHgZ60nQYBU2JwwQIA92cJTq7WNPc755kPis-1750948711509-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-06-26T14:38:31.473128+00:00"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "1517"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "1755"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999935"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "1ms"
-          ],
-          "x-request-id": [
-            "req_d080086a047a3f24c260505e4deb1525"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"input\":\"Question: Here's a multiple choice question about Python data types:\\n\\n**Question:**  \\nWhich of the following is NOT a built-in data type in Python?\\n\\nA) List  \\nB) Dictionary  \\nC) Array  \\nD) Tuple  \\n\\n**Correct Answer:** C) Array\\n\\nMy answer is B because lists are mutable in Python.\",\"model\":\"gpt-4o-mini\",\"instructions\":\"Extract the user's multiple choice answer and their reasoning.\",\"text\":{\"format\":{\"type\":\"json_schema\",\"strict\":true,\"name\":\"MultipleChoiceResponse\",\"schema\":{\"properties\":{\"choice\":{\"enum\":[\"A\",\"B\",\"C\",\"D\"],\"title\":\"Choice\",\"type\":\"string\"},\"reasoning\":{\"anyOf\":[{\"type\":\"string\"},{\"type\":\"null\"}],\"title\":\"Reasoning\"}},\"required\":[\"choice\",\"reasoning\"],\"title\":\"MultipleChoiceResponse\",\"type\":\"object\",\"additionalProperties\":false}}}}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "777"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "cookie": [
-            "__cf_bm=YeohFDOvVAIqdBWH4xt8xbkB7IGA0HN8SVg2kGbd858-1750948711-1.0.1.1-halNkOUgL1e1ZZ7OA.wBX9gvR1oCenhXLA9H0wb1qeRaUk8SfBD6FMfb859sXDYMkF.468Br5vknv66.UkEDNXHqLN9N5Tu662dfFBT8fvc; _cfuvid=2NYlOVxaHgZ60nQYBU2JwwQIA92cJTq7WNPc755kPis-1750948711509-0.0.1.1-604800000"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.86.0"
-          ],
-          "x-stainless-arch": [
-            "arm64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "MacOS"
-          ],
-          "x-stainless-package-version": [
-            "1.86.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/responses"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"resp_685d5b679ef481929ffa3e10d3b6bd790615279e06b11653\",\n  \"object\": \"response\",\n  \"created_at\": 1750948711,\n  \"status\": \"completed\",\n  \"background\": false,\n  \"error\": null,\n  \"incomplete_details\": null,\n  \"instructions\": \"Extract the user's multiple choice answer and their reasoning.\",\n  \"max_output_tokens\": null,\n  \"max_tool_calls\": null,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"output\": [\n    {\n      \"id\": \"msg_685d5b67d3ac81929dabb1166c7626710615279e06b11653\",\n      \"type\": \"message\",\n      \"status\": \"completed\",\n      \"content\": [\n        {\n          \"type\": \"output_text\",\n          \"annotations\": [],\n          \"text\": \"{\\\"choice\\\":\\\"B\\\",\\\"reasoning\\\":\\\"My answer is B because lists are mutable in Python.\\\"}\"\n        }\n      ],\n      \"role\": \"assistant\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"previous_response_id\": null,\n  \"reasoning\": {\n    \"effort\": null,\n    \"summary\": null\n  },\n  \"service_tier\": \"default\",\n  \"store\": true,\n  \"temperature\": 1.0,\n  \"text\": {\n    \"format\": {\n      \"type\": \"json_schema\",\n      \"description\": null,\n      \"name\": \"MultipleChoiceResponse\",\n      \"schema\": {\n        \"properties\": {\n          \"choice\": {\n            \"enum\": [\n              \"A\",\n              \"B\",\n              \"C\",\n              \"D\"\n            ],\n            \"title\": \"Choice\",\n            \"type\": \"string\"\n          },\n          \"reasoning\": {\n            \"anyOf\": [\n              {\n                \"type\": \"string\"\n              },\n              {\n                \"type\": \"null\"\n              }\n            ],\n            \"title\": \"Reasoning\"\n          }\n        },\n        \"required\": [\n          \"choice\",\n          \"reasoning\"\n        ],\n        \"title\": \"MultipleChoiceResponse\",\n        \"type\": \"object\",\n        \"additionalProperties\": false\n      },\n      \"strict\": true\n    }\n  },\n  \"tool_choice\": \"auto\",\n  \"tools\": [],\n  \"top_p\": 1.0,\n  \"truncation\": \"disabled\",\n  \"usage\": {\n    \"input_tokens\": 153,\n    \"input_tokens_details\": {\n      \"cached_tokens\": 0\n    },\n    \"output_tokens\": 21,\n    \"output_tokens_details\": {\n      \"reasoning_tokens\": 0\n    },\n    \"total_tokens\": 174\n  },\n  \"user\": null,\n  \"metadata\": {}\n}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "955d72e71aadbb15-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 26 Jun 2025 14:38:32 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-06-26T14:38:32.153583+00:00"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "2163"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "537"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999827"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "5ms"
-          ],
-          "x-request-id": [
-            "req_45947f14378d77ce5adeb8826180dff4"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-06-26T14:38:32.181873+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/responses/assistant_preference_question.json b/crates/fixtures/data/openai/responses/assistant_preference_question.json
deleted file mode 100644
index 7cfef189..00000000
--- a/crates/fixtures/data/openai/responses/assistant_preference_question.json
+++ /dev/null
@@ -1,290 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"input\":\"Ask the user to choose between three options for a new feature: option1: AI-powered suggestions, option2: Advanced search filters, option3: Collaboration tools\",\"model\":\"gpt-4o-mini\",\"instructions\":\"Present the three options clearly and ask for their preference.\",\"stream\":false}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "289"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.86.0"
-          ],
-          "x-stainless-arch": [
-            "arm64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "MacOS"
-          ],
-          "x-stainless-package-version": [
-            "1.86.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/responses"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"resp_685d5b6de7b4819ebcbde1aa391e831b045a8375a3654b97\",\n  \"object\": \"response\",\n  \"created_at\": 1750948717,\n  \"status\": \"completed\",\n  \"background\": false,\n  \"error\": null,\n  \"incomplete_details\": null,\n  \"instructions\": \"Present the three options clearly and ask for their preference.\",\n  \"max_output_tokens\": null,\n  \"max_tool_calls\": null,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"output\": [\n    {\n      \"id\": \"msg_685d5b6f24f0819ea78cee5d2988d3d5045a8375a3654b97\",\n      \"type\": \"message\",\n      \"status\": \"completed\",\n      \"content\": [\n        {\n          \"type\": \"output_text\",\n          \"annotations\": [],\n          \"text\": \"Please choose one of the following options for a new feature:\\n\\n1. **AI-powered suggestions**\\n2. **Advanced search filters**\\n3. **Collaboration tools**\\n\\nWhich option do you prefer?\"\n        }\n      ],\n      \"role\": \"assistant\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"previous_response_id\": null,\n  \"reasoning\": {\n    \"effort\": null,\n    \"summary\": null\n  },\n  \"service_tier\": \"default\",\n  \"store\": true,\n  \"temperature\": 1.0,\n  \"text\": {\n    \"format\": {\n      \"type\": \"text\"\n    }\n  },\n  \"tool_choice\": \"auto\",\n  \"tools\": [],\n  \"top_p\": 1.0,\n  \"truncation\": \"disabled\",\n  \"usage\": {\n    \"input_tokens\": 54,\n    \"input_tokens_details\": {\n      \"cached_tokens\": 0\n    },\n    \"output_tokens\": 40,\n    \"output_tokens_details\": {\n      \"reasoning_tokens\": 0\n    },\n    \"total_tokens\": 94\n  },\n  \"user\": null,\n  \"metadata\": {}\n}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "955d730e5d82039d-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 26 Jun 2025 14:38:40 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=z2wYdqUHL4z8_BQuztM0wHe7aTSzZWF1DwrlrHZa..w-1750948720-1.0.1.1-F1LoU99qWJN2w5cu9T80.RTKKsXsH8peQHh5TTPqNgSpuKre8QxwubP0jF0BHwKGU7YRHwTVp9Ls3AM7uqVJWGN3TzAHE8tJiXG1LQ7EImw; path=/; expires=Thu, 26-Jun-25 15:08:40 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=UHfUP8RrqV0JySr2rJjXjkcx_fselHHRy6fSaybRHfc-1750948720589-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-06-26T14:38:40.547981+00:00"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "1475"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "2638"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999927"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "2ms"
-          ],
-          "x-request-id": [
-            "req_dc603199cf52c3b9402995fdb15b8a44"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"input\":\"Please choose one of the following options for a new feature:\\n\\n1. **AI-powered suggestions**\\n2. **Advanced search filters**\\n3. **Collaboration tools**\\n\\nWhich option do you prefer?\\n\\nI strongly prefer option1 (AI-powered suggestions) because it would save me the most time and provide personalized recommendations based on my usage patterns.\",\"model\":\"gpt-4o-mini\",\"instructions\":\"Extract the user's preference choice, how strongly they feel about it, and their explanation.\",\"text\":{\"format\":{\"type\":\"json_schema\",\"strict\":true,\"name\":\"PreferenceResponse\",\"schema\":{\"properties\":{\"preference\":{\"enum\":[\"option1\",\"option2\",\"option3\"],\"title\":\"Preference\",\"type\":\"string\"},\"strength\":{\"enum\":[\"strong\",\"moderate\",\"weak\"],\"title\":\"Strength\",\"type\":\"string\"},\"explanation\":{\"title\":\"Explanation\",\"type\":\"string\"}},\"required\":[\"preference\",\"strength\",\"explanation\"],\"title\":\"PreferenceResponse\",\"type\":\"object\",\"additionalProperties\":false}}}}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "955"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "cookie": [
-            "__cf_bm=z2wYdqUHL4z8_BQuztM0wHe7aTSzZWF1DwrlrHZa..w-1750948720-1.0.1.1-F1LoU99qWJN2w5cu9T80.RTKKsXsH8peQHh5TTPqNgSpuKre8QxwubP0jF0BHwKGU7YRHwTVp9Ls3AM7uqVJWGN3TzAHE8tJiXG1LQ7EImw; _cfuvid=UHfUP8RrqV0JySr2rJjXjkcx_fselHHRy6fSaybRHfc-1750948720589-0.0.1.1-604800000"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.86.0"
-          ],
-          "x-stainless-arch": [
-            "arm64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "MacOS"
-          ],
-          "x-stainless-package-version": [
-            "1.86.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/responses"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"resp_685d5b70ade4819c9022a3766091d8d40d7220bd0d7e74c0\",\n  \"object\": \"response\",\n  \"created_at\": 1750948720,\n  \"status\": \"completed\",\n  \"background\": false,\n  \"error\": null,\n  \"incomplete_details\": null,\n  \"instructions\": \"Extract the user's preference choice, how strongly they feel about it, and their explanation.\",\n  \"max_output_tokens\": null,\n  \"max_tool_calls\": null,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"output\": [\n    {\n      \"id\": \"msg_685d5b710094819c8a80389a6ec245a80d7220bd0d7e74c0\",\n      \"type\": \"message\",\n      \"status\": \"completed\",\n      \"content\": [\n        {\n          \"type\": \"output_text\",\n          \"annotations\": [],\n          \"text\": \"{\\\"preference\\\":\\\"option1\\\",\\\"strength\\\":\\\"strong\\\",\\\"explanation\\\":\\\"I strongly prefer option1 (AI-powered suggestions) because it would save me the most time and provide personalized recommendations based on my usage patterns.\\\"}\"\n        }\n      ],\n      \"role\": \"assistant\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"previous_response_id\": null,\n  \"reasoning\": {\n    \"effort\": null,\n    \"summary\": null\n  },\n  \"service_tier\": \"default\",\n  \"store\": true,\n  \"temperature\": 1.0,\n  \"text\": {\n    \"format\": {\n      \"type\": \"json_schema\",\n      \"description\": null,\n      \"name\": \"PreferenceResponse\",\n      \"schema\": {\n        \"properties\": {\n          \"preference\": {\n            \"enum\": [\n              \"option1\",\n              \"option2\",\n              \"option3\"\n            ],\n            \"title\": \"Preference\",\n            \"type\": \"string\"\n          },\n          \"strength\": {\n            \"enum\": [\n              \"strong\",\n              \"moderate\",\n              \"weak\"\n            ],\n            \"title\": \"Strength\",\n            \"type\": \"string\"\n          },\n          \"explanation\": {\n            \"title\": \"Explanation\",\n            \"type\": \"string\"\n          }\n        },\n        \"required\": [\n          \"preference\",\n          \"strength\",\n          \"explanation\"\n        ],\n        \"title\": \"PreferenceResponse\",\n        \"type\": \"object\",\n        \"additionalProperties\": false\n      },\n      \"strict\": true\n    }\n  },\n  \"tool_choice\": \"auto\",\n  \"tools\": [],\n  \"top_p\": 1.0,\n  \"truncation\": \"disabled\",\n  \"usage\": {\n    \"input_tokens\": 173,\n    \"input_tokens_details\": {\n      \"cached_tokens\": 0\n    },\n    \"output_tokens\": 44,\n    \"output_tokens_details\": {\n      \"reasoning_tokens\": 0\n    },\n    \"total_tokens\": 217\n  },\n  \"user\": null,\n  \"metadata\": {}\n}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "955d731fc857039d-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 26 Jun 2025 14:38:41 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-06-26T14:38:41.590665+00:00"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "2438"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "904"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999807"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "5ms"
-          ],
-          "x-request-id": [
-            "req_d9f3a7d5b0b3042af3b683c965ae4285"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-06-26T14:38:41.621302+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/responses/basic_response.json b/crates/fixtures/data/openai/responses/basic_response.json
deleted file mode 100644
index db125ef9..00000000
--- a/crates/fixtures/data/openai/responses/basic_response.json
+++ /dev/null
@@ -1,150 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"input\":\"What is 2+2?\",\"model\":\"gpt-4o-mini\",\"stream\":false}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "61"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.86.0"
-          ],
-          "x-stainless-arch": [
-            "arm64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "MacOS"
-          ],
-          "x-stainless-package-version": [
-            "1.86.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/responses"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"resp_685d56382a64819e84db417d512c435d0181f2add099fccc\",\n  \"object\": \"response\",\n  \"created_at\": 1750947384,\n  \"status\": \"completed\",\n  \"background\": false,\n  \"error\": null,\n  \"incomplete_details\": null,\n  \"instructions\": null,\n  \"max_output_tokens\": null,\n  \"max_tool_calls\": null,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"output\": [\n    {\n      \"id\": \"msg_685d56388a6c819ebe5e23a687136d210181f2add099fccc\",\n      \"type\": \"message\",\n      \"status\": \"completed\",\n      \"content\": [\n        {\n          \"type\": \"output_text\",\n          \"annotations\": [],\n          \"text\": \"2 + 2 equals 4.\"\n        }\n      ],\n      \"role\": \"assistant\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"previous_response_id\": null,\n  \"reasoning\": {\n    \"effort\": null,\n    \"summary\": null\n  },\n  \"service_tier\": \"default\",\n  \"store\": true,\n  \"temperature\": 1.0,\n  \"text\": {\n    \"format\": {\n      \"type\": \"text\"\n    }\n  },\n  \"tool_choice\": \"auto\",\n  \"tools\": [],\n  \"top_p\": 1.0,\n  \"truncation\": \"disabled\",\n  \"usage\": {\n    \"input_tokens\": 14,\n    \"input_tokens_details\": {\n      \"cached_tokens\": 0\n    },\n    \"output_tokens\": 9,\n    \"output_tokens_details\": {\n      \"reasoning_tokens\": 0\n    },\n    \"total_tokens\": 23\n  },\n  \"user\": null,\n  \"metadata\": {}\n}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "955d527e5ce50200-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 26 Jun 2025 14:16:24 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=py4xepsPXRImASk9bOvX5bB3DCsYhYtChRuaCViNE2k-1750947384-1.0.1.1-iBZMPnIWVj_72WzsD8gxfsrLu1uIiznxHp9HJM0iJBR38zfs_XhzsOBFsJierDIoBA2J2M7v8MtpZkp9Qkkrc8qIoB3xoOeFdXw2T0efN.k; path=/; expires=Thu, 26-Jun-25 14:46:24 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=9nxIP1K82t8u9NmE7Yzp4lQiQFqbEthOuivucn5T3U0-1750947384806-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-06-26T14:16:24.756232+00:00"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "1243"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "600"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999967"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "0s"
-          ],
-          "x-request-id": [
-            "req_cf8ce0770bf6762e03817b13d22a1d8f"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-06-26T14:16:24.762569+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/responses/basic_streaming.json b/crates/fixtures/data/openai/responses/basic_streaming.json
deleted file mode 100644
index 25be4f78..00000000
--- a/crates/fixtures/data/openai/responses/basic_streaming.json
+++ /dev/null
@@ -1,132 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"input\":\"What is 2+2?\",\"model\":\"gpt-4o-mini\",\"stream\":true}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "60"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.86.0"
-          ],
-          "x-stainless-arch": [
-            "arm64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "MacOS"
-          ],
-          "x-stainless-package-version": [
-            "1.86.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/responses"
-      },
-      "response": {
-        "body": {
-          "string": "event: response.created\ndata: {\"type\":\"response.created\",\"sequence_number\":0,\"response\":{\"id\":\"resp_685d5638e824819fbffbe392ce661982080fe1cffaa27f70\",\"object\":\"response\",\"created_at\":1750947384,\"status\":\"in_progress\",\"background\":false,\"error\":null,\"incomplete_details\":null,\"instructions\":null,\"max_output_tokens\":null,\"max_tool_calls\":null,\"model\":\"gpt-4o-mini-2024-07-18\",\"output\":[],\"parallel_tool_calls\":true,\"previous_response_id\":null,\"reasoning\":{\"effort\":null,\"summary\":null},\"service_tier\":\"auto\",\"store\":true,\"temperature\":1.0,\"text\":{\"format\":{\"type\":\"text\"}},\"tool_choice\":\"auto\",\"tools\":[],\"top_p\":1.0,\"truncation\":\"disabled\",\"usage\":null,\"user\":null,\"metadata\":{}}}\n\nevent: response.in_progress\ndata: {\"type\":\"response.in_progress\",\"sequence_number\":1,\"response\":{\"id\":\"resp_685d5638e824819fbffbe392ce661982080fe1cffaa27f70\",\"object\":\"response\",\"created_at\":1750947384,\"status\":\"in_progress\",\"background\":false,\"error\":null,\"incomplete_details\":null,\"instructions\":null,\"max_output_tokens\":null,\"max_tool_calls\":null,\"model\":\"gpt-4o-mini-2024-07-18\",\"output\":[],\"parallel_tool_calls\":true,\"previous_response_id\":null,\"reasoning\":{\"effort\":null,\"summary\":null},\"service_tier\":\"auto\",\"store\":true,\"temperature\":1.0,\"text\":{\"format\":{\"type\":\"text\"}},\"tool_choice\":\"auto\",\"tools\":[],\"top_p\":1.0,\"truncation\":\"disabled\",\"usage\":null,\"user\":null,\"metadata\":{}}}\n\nevent: response.output_item.added\ndata: {\"type\":\"response.output_item.added\",\"sequence_number\":2,\"output_index\":0,\"item\":{\"id\":\"msg_685d56393e10819f9ebe2f330e8589f4080fe1cffaa27f70\",\"type\":\"message\",\"status\":\"in_progress\",\"content\":[],\"role\":\"assistant\"}}\n\nevent: response.content_part.added\ndata: {\"type\":\"response.content_part.added\",\"sequence_number\":3,\"item_id\":\"msg_685d56393e10819f9ebe2f330e8589f4080fe1cffaa27f70\",\"output_index\":0,\"content_index\":0,\"part\":{\"type\":\"output_text\",\"annotations\":[],\"text\":\"\"}}\n\nevent: response.output_text.delta\ndata: {\"type\":\"response.output_text.delta\",\"sequence_number\":4,\"item_id\":\"msg_685d56393e10819f9ebe2f330e8589f4080fe1cffaa27f70\",\"output_index\":0,\"content_index\":0,\"delta\":\"2\"}\n\nevent: response.output_text.delta\ndata: {\"type\":\"response.output_text.delta\",\"sequence_number\":5,\"item_id\":\"msg_685d56393e10819f9ebe2f330e8589f4080fe1cffaa27f70\",\"output_index\":0,\"content_index\":0,\"delta\":\" +\"}\n\nevent: response.output_text.delta\ndata: {\"type\":\"response.output_text.delta\",\"sequence_number\":6,\"item_id\":\"msg_685d56393e10819f9ebe2f330e8589f4080fe1cffaa27f70\",\"output_index\":0,\"content_index\":0,\"delta\":\" \"}\n\nevent: response.output_text.delta\ndata: {\"type\":\"response.output_text.delta\",\"sequence_number\":7,\"item_id\":\"msg_685d56393e10819f9ebe2f330e8589f4080fe1cffaa27f70\",\"output_index\":0,\"content_index\":0,\"delta\":\"2\"}\n\nevent: response.output_text.delta\ndata: {\"type\":\"response.output_text.delta\",\"sequence_number\":8,\"item_id\":\"msg_685d56393e10819f9ebe2f330e8589f4080fe1cffaa27f70\",\"output_index\":0,\"content_index\":0,\"delta\":\" equals\"}\n\nevent: response.output_text.delta\ndata: {\"type\":\"response.output_text.delta\",\"sequence_number\":9,\"item_id\":\"msg_685d56393e10819f9ebe2f330e8589f4080fe1cffaa27f70\",\"output_index\":0,\"content_index\":0,\"delta\":\" \"}\n\nevent: response.output_text.delta\ndata: {\"type\":\"response.output_text.delta\",\"sequence_number\":10,\"item_id\":\"msg_685d56393e10819f9ebe2f330e8589f4080fe1cffaa27f70\",\"output_index\":0,\"content_index\":0,\"delta\":\"4\"}\n\nevent: response.output_text.delta\ndata: {\"type\":\"response.output_text.delta\",\"sequence_number\":11,\"item_id\":\"msg_685d56393e10819f9ebe2f330e8589f4080fe1cffaa27f70\",\"output_index\":0,\"content_index\":0,\"delta\":\".\"}\n\nevent: response.output_text.done\ndata: {\"type\":\"response.output_text.done\",\"sequence_number\":12,\"item_id\":\"msg_685d56393e10819f9ebe2f330e8589f4080fe1cffaa27f70\",\"output_index\":0,\"content_index\":0,\"text\":\"2 + 2 equals 4.\"}\n\nevent: response.content_part.done\ndata: {\"type\":\"response.content_part.done\",\"sequence_number\":13,\"item_id\":\"msg_685d56393e10819f9ebe2f330e8589f4080fe1cffaa27f70\",\"output_index\":0,\"content_index\":0,\"part\":{\"type\":\"output_text\",\"annotations\":[],\"text\":\"2 + 2 equals 4.\"}}\n\nevent: response.output_item.done\ndata: {\"type\":\"response.output_item.done\",\"sequence_number\":14,\"output_index\":0,\"item\":{\"id\":\"msg_685d56393e10819f9ebe2f330e8589f4080fe1cffaa27f70\",\"type\":\"message\",\"status\":\"completed\",\"content\":[{\"type\":\"output_text\",\"annotations\":[],\"text\":\"2 + 2 equals 4.\"}],\"role\":\"assistant\"}}\n\nevent: response.completed\ndata: {\"type\":\"response.completed\",\"sequence_number\":15,\"response\":{\"id\":\"resp_685d5638e824819fbffbe392ce661982080fe1cffaa27f70\",\"object\":\"response\",\"created_at\":1750947384,\"status\":\"completed\",\"background\":false,\"error\":null,\"incomplete_details\":null,\"instructions\":null,\"max_output_tokens\":null,\"max_tool_calls\":null,\"model\":\"gpt-4o-mini-2024-07-18\",\"output\":[{\"id\":\"msg_685d56393e10819f9ebe2f330e8589f4080fe1cffaa27f70\",\"type\":\"message\",\"status\":\"completed\",\"content\":[{\"type\":\"output_text\",\"annotations\":[],\"text\":\"2 + 2 equals 4.\"}],\"role\":\"assistant\"}],\"parallel_tool_calls\":true,\"previous_response_id\":null,\"reasoning\":{\"effort\":null,\"summary\":null},\"service_tier\":\"default\",\"store\":true,\"temperature\":1.0,\"text\":{\"format\":{\"type\":\"text\"}},\"tool_choice\":\"auto\",\"tools\":[],\"top_p\":1.0,\"truncation\":\"disabled\",\"usage\":{\"input_tokens\":14,\"input_tokens_details\":{\"cached_tokens\":0},\"output_tokens\":9,\"output_tokens_details\":{\"reasoning_tokens\":0},\"total_tokens\":23},\"user\":null,\"metadata\":{}}}\n\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "955d52833f2ae5d9-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "text/event-stream; charset=utf-8"
-          ],
-          "Date": [
-            "Thu, 26 Jun 2025 14:16:24 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=fQtsO6tuy9MHU5VNhusH32fC2YeoIT5asmZGDE5XBqY-1750947384-1.0.1.1-zriNnbkbU8l1SfCXOCOEGqwbnsHPk57ZYF_KgXkhlxqJ8zYAFWUXYNFnD0LHyX8fK4WS_VcT5JEOGgaDbRg_23PEZWFwh57j6Q8.Rjk88BY; path=/; expires=Thu, 26-Jun-25 14:46:24 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=LvQWDv6ETW2sPQCFVmxCtHubiBpfa7BTDhtszqRErpQ-1750947384973-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-06-26T14:16:25.443159+00:00"
-          ],
-          "X-VCR-SSE-Response": [
-            "true"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "24"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-request-id": [
-            "req_6d5b2f3904f1d647f3b5ecd6e544ce51"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-06-26T14:16:25.484919+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/responses/conversation_flow_with_structured_responses.json b/crates/fixtures/data/openai/responses/conversation_flow_with_structured_responses.json
deleted file mode 100644
index d85edaa7..00000000
--- a/crates/fixtures/data/openai/responses/conversation_flow_with_structured_responses.json
+++ /dev/null
@@ -1,570 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"input\":\"Ask the user about their Python programming experience level\",\"model\":\"gpt-4o-mini\",\"stream\":false}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "109"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.86.0"
-          ],
-          "x-stainless-arch": [
-            "arm64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "MacOS"
-          ],
-          "x-stainless-package-version": [
-            "1.86.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/responses"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"resp_685d5b774dc881a281bcacee98ee9de804c5394be752abef\",\n  \"object\": \"response\",\n  \"created_at\": 1750948727,\n  \"status\": \"completed\",\n  \"background\": false,\n  \"error\": null,\n  \"incomplete_details\": null,\n  \"instructions\": null,\n  \"max_output_tokens\": null,\n  \"max_tool_calls\": null,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"output\": [\n    {\n      \"id\": \"msg_685d5b777ce481a296e55cb31163c25b04c5394be752abef\",\n      \"type\": \"message\",\n      \"status\": \"completed\",\n      \"content\": [\n        {\n          \"type\": \"output_text\",\n          \"annotations\": [],\n          \"text\": \"Sure! How would you describe your Python programming experience level?\\n\\n1. **Beginner**: Just starting out, new to programming.\\n2. **Intermediate**: Have some experience, comfortable with basic concepts.\\n3. **Advanced**: Proficient, familiar with more complex topics and capable of building projects.\\n4. **Expert**: Highly experienced, deep understanding of Python and its libraries.\\n\\nFeel free to elaborate on your experience if you'd like!\"\n        }\n      ],\n      \"role\": \"assistant\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"previous_response_id\": null,\n  \"reasoning\": {\n    \"effort\": null,\n    \"summary\": null\n  },\n  \"service_tier\": \"default\",\n  \"store\": true,\n  \"temperature\": 1.0,\n  \"text\": {\n    \"format\": {\n      \"type\": \"text\"\n    }\n  },\n  \"tool_choice\": \"auto\",\n  \"tools\": [],\n  \"top_p\": 1.0,\n  \"truncation\": \"disabled\",\n  \"usage\": {\n    \"input_tokens\": 16,\n    \"input_tokens_details\": {\n      \"cached_tokens\": 0\n    },\n    \"output_tokens\": 92,\n    \"output_tokens_details\": {\n      \"reasoning_tokens\": 0\n    },\n    \"total_tokens\": 108\n  },\n  \"user\": null,\n  \"metadata\": {}\n}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "955d73493f822355-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 26 Jun 2025 14:38:48 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=1Oa7uNmJut9G9ApYeeboFOiceqDA7XIAh.RRnxxKPPc-1750948728-1.0.1.1-3rnbFj_.oZR7VuZtupkiYOn0vxNW51fsoWvofUEmG6qy.5R1yFIY5CogDjjz0VaiPfNho9F49XlPj26AOIZO8VgE2MHdOjjr5JEAYF_8_90; path=/; expires=Thu, 26-Jun-25 15:08:48 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=wnwz0JjNhAQ8Jqgdl5bgIOps1SnYRueUx9uQx23DMVg-1750948728857-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-06-26T14:38:48.821230+00:00"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "1678"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "1460"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999964"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "1ms"
-          ],
-          "x-request-id": [
-            "req_ca4ef71e8653d0bbb6045084682fdd88"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"input\":\"I'm an intermediate Python developer with about 3 years of experience\",\"model\":\"gpt-4o-mini\",\"text\":{\"format\":{\"type\":\"json_schema\",\"strict\":true,\"name\":\"ExperienceLevel\",\"schema\":{\"properties\":{\"level\":{\"enum\":[\"beginner\",\"intermediate\",\"advanced\"],\"title\":\"Level\",\"type\":\"string\"},\"years\":{\"anyOf\":[{\"type\":\"integer\"},{\"type\":\"null\"}],\"title\":\"Years\"}},\"required\":[\"level\",\"years\"],\"title\":\"ExperienceLevel\",\"type\":\"object\",\"additionalProperties\":false}}}}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "468"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "cookie": [
-            "__cf_bm=1Oa7uNmJut9G9ApYeeboFOiceqDA7XIAh.RRnxxKPPc-1750948728-1.0.1.1-3rnbFj_.oZR7VuZtupkiYOn0vxNW51fsoWvofUEmG6qy.5R1yFIY5CogDjjz0VaiPfNho9F49XlPj26AOIZO8VgE2MHdOjjr5JEAYF_8_90; _cfuvid=wnwz0JjNhAQ8Jqgdl5bgIOps1SnYRueUx9uQx23DMVg-1750948728857-0.0.1.1-604800000"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.86.0"
-          ],
-          "x-stainless-arch": [
-            "arm64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "MacOS"
-          ],
-          "x-stainless-package-version": [
-            "1.86.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/responses"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"resp_685d5b78fc44819e88ba3892eda9dbe0096da2f17d578c9e\",\n  \"object\": \"response\",\n  \"created_at\": 1750948728,\n  \"status\": \"completed\",\n  \"background\": false,\n  \"error\": null,\n  \"incomplete_details\": null,\n  \"instructions\": null,\n  \"max_output_tokens\": null,\n  \"max_tool_calls\": null,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"output\": [\n    {\n      \"id\": \"msg_685d5b793b7c819e9be7b5725a8c1ab8096da2f17d578c9e\",\n      \"type\": \"message\",\n      \"status\": \"completed\",\n      \"content\": [\n        {\n          \"type\": \"output_text\",\n          \"annotations\": [],\n          \"text\": \"{\\\"level\\\":\\\"intermediate\\\",\\\"years\\\":3}\"\n        }\n      ],\n      \"role\": \"assistant\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"previous_response_id\": null,\n  \"reasoning\": {\n    \"effort\": null,\n    \"summary\": null\n  },\n  \"service_tier\": \"default\",\n  \"store\": true,\n  \"temperature\": 1.0,\n  \"text\": {\n    \"format\": {\n      \"type\": \"json_schema\",\n      \"description\": null,\n      \"name\": \"ExperienceLevel\",\n      \"schema\": {\n        \"properties\": {\n          \"level\": {\n            \"enum\": [\n              \"beginner\",\n              \"intermediate\",\n              \"advanced\"\n            ],\n            \"title\": \"Level\",\n            \"type\": \"string\"\n          },\n          \"years\": {\n            \"anyOf\": [\n              {\n                \"type\": \"integer\"\n              },\n              {\n                \"type\": \"null\"\n              }\n            ],\n            \"title\": \"Years\"\n          }\n        },\n        \"required\": [\n          \"level\",\n          \"years\"\n        ],\n        \"title\": \"ExperienceLevel\",\n        \"type\": \"object\",\n        \"additionalProperties\": false\n      },\n      \"strict\": true\n    }\n  },\n  \"tool_choice\": \"auto\",\n  \"tools\": [],\n  \"top_p\": 1.0,\n  \"truncation\": \"disabled\",\n  \"usage\": {\n    \"input_tokens\": 82,\n    \"input_tokens_details\": {\n      \"cached_tokens\": 0\n    },\n    \"output_tokens\": 11,\n    \"output_tokens_details\": {\n      \"reasoning_tokens\": 0\n    },\n    \"total_tokens\": 93\n  },\n  \"user\": null,\n  \"metadata\": {}\n}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "955d73539b472355-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 26 Jun 2025 14:38:49 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-06-26T14:38:49.443448+00:00"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "2031"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "454"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999898"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "3ms"
-          ],
-          "x-request-id": [
-            "req_0e243a24d88a0e65b8af48fa5637cfba"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"input\":\"The user is intermediate with 3 years experience. Ask them which Python topics they're interested in: web development, data science, automation, or machine learning\",\"model\":\"gpt-4o-mini\",\"previous_response_id\":\"resp_685d5b774dc881a281bcacee98ee9de804c5394be752abef\",\"stream\":false}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "292"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "cookie": [
-            "__cf_bm=1Oa7uNmJut9G9ApYeeboFOiceqDA7XIAh.RRnxxKPPc-1750948728-1.0.1.1-3rnbFj_.oZR7VuZtupkiYOn0vxNW51fsoWvofUEmG6qy.5R1yFIY5CogDjjz0VaiPfNho9F49XlPj26AOIZO8VgE2MHdOjjr5JEAYF_8_90; _cfuvid=wnwz0JjNhAQ8Jqgdl5bgIOps1SnYRueUx9uQx23DMVg-1750948728857-0.0.1.1-604800000"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.86.0"
-          ],
-          "x-stainless-arch": [
-            "arm64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "MacOS"
-          ],
-          "x-stainless-package-version": [
-            "1.86.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/responses"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"resp_685d5b7999f081a2b78a9f97f468b98404c5394be752abef\",\n  \"object\": \"response\",\n  \"created_at\": 1750948729,\n  \"status\": \"completed\",\n  \"background\": false,\n  \"error\": null,\n  \"incomplete_details\": null,\n  \"instructions\": null,\n  \"max_output_tokens\": null,\n  \"max_tool_calls\": null,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"output\": [\n    {\n      \"id\": \"msg_685d5b79e00881a2b0987de74e1e201304c5394be752abef\",\n      \"type\": \"message\",\n      \"status\": \"completed\",\n      \"content\": [\n        {\n          \"type\": \"output_text\",\n          \"annotations\": [],\n          \"text\": \"Great to hear you have three years of experience! Which Python topics are you most interested in exploring further? Here are some options:\\n\\n1. **Web Development**\\n2. **Data Science**\\n3. **Automation**\\n4. **Machine Learning**\\n\\nFeel free to choose one or more, or add any other topics that interest you!\"\n        }\n      ],\n      \"role\": \"assistant\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"previous_response_id\": \"resp_685d5b774dc881a281bcacee98ee9de804c5394be752abef\",\n  \"reasoning\": {\n    \"effort\": null,\n    \"summary\": null\n  },\n  \"service_tier\": \"default\",\n  \"store\": true,\n  \"temperature\": 1.0,\n  \"text\": {\n    \"format\": {\n      \"type\": \"text\"\n    }\n  },\n  \"tool_choice\": \"auto\",\n  \"tools\": [],\n  \"top_p\": 1.0,\n  \"truncation\": \"disabled\",\n  \"usage\": {\n    \"input_tokens\": 145,\n    \"input_tokens_details\": {\n      \"cached_tokens\": 0\n    },\n    \"output_tokens\": 67,\n    \"output_tokens_details\": {\n      \"reasoning_tokens\": 0\n    },\n    \"total_tokens\": 212\n  },\n  \"user\": null,\n  \"metadata\": {}\n}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "955d73578d552355-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 26 Jun 2025 14:38:52 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-06-26T14:38:52.922739+00:00"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "1590"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "3318"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999836"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "4ms"
-          ],
-          "x-request-id": [
-            "req_662346dbf5631ac674c9136c35dbc894"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"input\":\"I'm interested in both data science and machine learning, but I'm most interested in machine learning\",\"model\":\"gpt-4o-mini\",\"text\":{\"format\":{\"type\":\"json_schema\",\"strict\":true,\"name\":\"TopicInterest\",\"schema\":{\"properties\":{\"topics\":{\"items\":{\"enum\":[\"web_dev\",\"data_science\",\"automation\",\"machine_learning\"],\"type\":\"string\"},\"title\":\"Topics\",\"type\":\"array\"},\"most_interested\":{\"enum\":[\"web_dev\",\"data_science\",\"automation\",\"machine_learning\"],\"title\":\"Most Interested\",\"type\":\"string\"}},\"required\":[\"topics\",\"most_interested\"],\"title\":\"TopicInterest\",\"type\":\"object\",\"additionalProperties\":false}}}}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "611"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "cookie": [
-            "__cf_bm=1Oa7uNmJut9G9ApYeeboFOiceqDA7XIAh.RRnxxKPPc-1750948728-1.0.1.1-3rnbFj_.oZR7VuZtupkiYOn0vxNW51fsoWvofUEmG6qy.5R1yFIY5CogDjjz0VaiPfNho9F49XlPj26AOIZO8VgE2MHdOjjr5JEAYF_8_90; _cfuvid=wnwz0JjNhAQ8Jqgdl5bgIOps1SnYRueUx9uQx23DMVg-1750948728857-0.0.1.1-604800000"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.86.0"
-          ],
-          "x-stainless-arch": [
-            "arm64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "MacOS"
-          ],
-          "x-stainless-package-version": [
-            "1.86.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/responses"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"resp_685d5b7d0c088192ae6af76a80a658d70186b993d27e824e\",\n  \"object\": \"response\",\n  \"created_at\": 1750948733,\n  \"status\": \"completed\",\n  \"background\": false,\n  \"error\": null,\n  \"incomplete_details\": null,\n  \"instructions\": null,\n  \"max_output_tokens\": null,\n  \"max_tool_calls\": null,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"output\": [\n    {\n      \"id\": \"msg_685d5b7d56d881929a42e16901eef44c0186b993d27e824e\",\n      \"type\": \"message\",\n      \"status\": \"completed\",\n      \"content\": [\n        {\n          \"type\": \"output_text\",\n          \"annotations\": [],\n          \"text\": \"{\\\"topics\\\":[\\\"data_science\\\",\\\"machine_learning\\\"],\\\"most_interested\\\":\\\"machine_learning\\\"}\"\n        }\n      ],\n      \"role\": \"assistant\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"previous_response_id\": null,\n  \"reasoning\": {\n    \"effort\": null,\n    \"summary\": null\n  },\n  \"service_tier\": \"default\",\n  \"store\": true,\n  \"temperature\": 1.0,\n  \"text\": {\n    \"format\": {\n      \"type\": \"json_schema\",\n      \"description\": null,\n      \"name\": \"TopicInterest\",\n      \"schema\": {\n        \"properties\": {\n          \"topics\": {\n            \"items\": {\n              \"enum\": [\n                \"web_dev\",\n                \"data_science\",\n                \"automation\",\n                \"machine_learning\"\n              ],\n              \"type\": \"string\"\n            },\n            \"title\": \"Topics\",\n            \"type\": \"array\"\n          },\n          \"most_interested\": {\n            \"enum\": [\n              \"web_dev\",\n              \"data_science\",\n              \"automation\",\n              \"machine_learning\"\n            ],\n            \"title\": \"Most Interested\",\n            \"type\": \"string\"\n          }\n        },\n        \"required\": [\n          \"topics\",\n          \"most_interested\"\n        ],\n        \"title\": \"TopicInterest\",\n        \"type\": \"object\",\n        \"additionalProperties\": false\n      },\n      \"strict\": true\n    }\n  },\n  \"tool_choice\": \"auto\",\n  \"tools\": [],\n  \"top_p\": 1.0,\n  \"truncation\": \"disabled\",\n  \"usage\": {\n    \"input_tokens\": 107,\n    \"input_tokens_details\": {\n      \"cached_tokens\": 0\n    },\n    \"output_tokens\": 19,\n    \"output_tokens_details\": {\n      \"reasoning_tokens\": 0\n    },\n    \"total_tokens\": 126\n  },\n  \"user\": null,\n  \"metadata\": {}\n}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "955d736d186e2355-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 26 Jun 2025 14:38:53 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-06-26T14:38:53.621212+00:00"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "2245"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "571"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999873"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "3ms"
-          ],
-          "x-request-id": [
-            "req_c043984ac00254cca1e647b21b28c51d"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-06-26T14:38:53.647448+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/responses/conversation_with_context.json b/crates/fixtures/data/openai/responses/conversation_with_context.json
deleted file mode 100644
index 39bdc618..00000000
--- a/crates/fixtures/data/openai/responses/conversation_with_context.json
+++ /dev/null
@@ -1,290 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"input\":\"Remember the number 42\",\"model\":\"gpt-4o-mini\",\"stream\":false}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "71"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.86.0"
-          ],
-          "x-stainless-arch": [
-            "arm64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "MacOS"
-          ],
-          "x-stainless-package-version": [
-            "1.86.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/responses"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"resp_685d563b48b481a3af5c0ebe0d3827db0daf7a4107440fff\",\n  \"object\": \"response\",\n  \"created_at\": 1750947387,\n  \"status\": \"completed\",\n  \"background\": false,\n  \"error\": null,\n  \"incomplete_details\": null,\n  \"instructions\": null,\n  \"max_output_tokens\": null,\n  \"max_tool_calls\": null,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"output\": [\n    {\n      \"id\": \"msg_685d563b8ea081a3b45a0250f5bf371d0daf7a4107440fff\",\n      \"type\": \"message\",\n      \"status\": \"completed\",\n      \"content\": [\n        {\n          \"type\": \"output_text\",\n          \"annotations\": [],\n          \"text\": \"Got it! The number 42 is noted. What would you like to do with it?\"\n        }\n      ],\n      \"role\": \"assistant\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"previous_response_id\": null,\n  \"reasoning\": {\n    \"effort\": null,\n    \"summary\": null\n  },\n  \"service_tier\": \"default\",\n  \"store\": true,\n  \"temperature\": 1.0,\n  \"text\": {\n    \"format\": {\n      \"type\": \"text\"\n    }\n  },\n  \"tool_choice\": \"auto\",\n  \"tools\": [],\n  \"top_p\": 1.0,\n  \"truncation\": \"disabled\",\n  \"usage\": {\n    \"input_tokens\": 12,\n    \"input_tokens_details\": {\n      \"cached_tokens\": 0\n    },\n    \"output_tokens\": 20,\n    \"output_tokens_details\": {\n      \"reasoning_tokens\": 0\n    },\n    \"total_tokens\": 32\n  },\n  \"user\": null,\n  \"metadata\": {}\n}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "955d5291edfb343e-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 26 Jun 2025 14:16:27 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=fZTdd.nhqUgfqTpuG.um50cbLGnLHs823vZmhoTj_tQ-1750947387-1.0.1.1-G352HQgVgeRHxeGRCOym9Bvv61UK2UX7uNJ0JKIPQSHF0Y9.vSIkUYfDKb54BihZwrNFgygOBfcmpUwLc8mUkzJXZcgNo32O5qodlFObsgw; path=/; expires=Thu, 26-Jun-25 14:46:27 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=RzNzR35Dqy.qG4Ggy4oEZWwaUVuvk660eZnk5bFu4.E-1750947387846-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-06-26T14:16:27.794294+00:00"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "1295"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "518"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999969"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "0s"
-          ],
-          "x-request-id": [
-            "req_05c5187adc4bff64f218792f0c3aa24b"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    },
-    {
-      "request": {
-        "body": "{\"input\":\"What number did I ask you to remember?\",\"model\":\"gpt-4o-mini\",\"previous_response_id\":\"resp_685d563b48b481a3af5c0ebe0d3827db0daf7a4107440fff\",\"stream\":false}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "166"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "cookie": [
-            "__cf_bm=fZTdd.nhqUgfqTpuG.um50cbLGnLHs823vZmhoTj_tQ-1750947387-1.0.1.1-G352HQgVgeRHxeGRCOym9Bvv61UK2UX7uNJ0JKIPQSHF0Y9.vSIkUYfDKb54BihZwrNFgygOBfcmpUwLc8mUkzJXZcgNo32O5qodlFObsgw; _cfuvid=RzNzR35Dqy.qG4Ggy4oEZWwaUVuvk660eZnk5bFu4.E-1750947387846-0.0.1.1-604800000"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.86.0"
-          ],
-          "x-stainless-arch": [
-            "arm64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "MacOS"
-          ],
-          "x-stainless-package-version": [
-            "1.86.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/responses"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"resp_685d563beaf881a38d9598d1d0df3be90daf7a4107440fff\",\n  \"object\": \"response\",\n  \"created_at\": 1750947387,\n  \"status\": \"completed\",\n  \"background\": false,\n  \"error\": null,\n  \"incomplete_details\": null,\n  \"instructions\": null,\n  \"max_output_tokens\": null,\n  \"max_tool_calls\": null,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"output\": [\n    {\n      \"id\": \"msg_685d563c8cb081a391a6d9061a5502ee0daf7a4107440fff\",\n      \"type\": \"message\",\n      \"status\": \"completed\",\n      \"content\": [\n        {\n          \"type\": \"output_text\",\n          \"annotations\": [],\n          \"text\": \"You asked me to remember the number 42.\"\n        }\n      ],\n      \"role\": \"assistant\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"previous_response_id\": \"resp_685d563b48b481a3af5c0ebe0d3827db0daf7a4107440fff\",\n  \"reasoning\": {\n    \"effort\": null,\n    \"summary\": null\n  },\n  \"service_tier\": \"default\",\n  \"store\": true,\n  \"temperature\": 1.0,\n  \"text\": {\n    \"format\": {\n      \"type\": \"text\"\n    }\n  },\n  \"tool_choice\": \"auto\",\n  \"tools\": [],\n  \"top_p\": 1.0,\n  \"truncation\": \"disabled\",\n  \"usage\": {\n    \"input_tokens\": 48,\n    \"input_tokens_details\": {\n      \"cached_tokens\": 0\n    },\n    \"output_tokens\": 11,\n    \"output_tokens_details\": {\n      \"reasoning_tokens\": 0\n    },\n    \"total_tokens\": 59\n  },\n  \"user\": null,\n  \"metadata\": {}\n}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "955d52961d1a343e-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 26 Jun 2025 14:16:28 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-06-26T14:16:28.701452+00:00"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "1319"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "788"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999932"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "2ms"
-          ],
-          "x-request-id": [
-            "req_a99eda78408df23c7457c569a4ecae45"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-06-26T14:16:28.703731+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/responses/function_calling_non_streaming.json b/crates/fixtures/data/openai/responses/function_calling_non_streaming.json
deleted file mode 100644
index 5c90ae80..00000000
--- a/crates/fixtures/data/openai/responses/function_calling_non_streaming.json
+++ /dev/null
@@ -1,150 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"input\":\"Calculate 1234 * 5678\",\"model\":\"gpt-4o-mini\",\"stream\":false,\"tools\":[{\"type\":\"function\",\"name\":\"calculate\",\"description\":\"Perform mathematical calculations\",\"parameters\":{\"type\":\"object\",\"properties\":{\"expression\":{\"type\":\"string\",\"description\":\"Mathematical expression to evaluate\"}},\"required\":[\"expression\"]}}]}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "324"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.86.0"
-          ],
-          "x-stainless-arch": [
-            "arm64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "MacOS"
-          ],
-          "x-stainless-package-version": [
-            "1.86.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/responses"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"resp_685d568c2638819290f1891cbd1a1ccb0beccc89b05cf700\",\n  \"object\": \"response\",\n  \"created_at\": 1750947468,\n  \"status\": \"completed\",\n  \"background\": false,\n  \"error\": null,\n  \"incomplete_details\": null,\n  \"instructions\": null,\n  \"max_output_tokens\": null,\n  \"max_tool_calls\": null,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"output\": [\n    {\n      \"id\": \"fc_685d568c7acc81928cc1fcb166c428a00beccc89b05cf700\",\n      \"type\": \"function_call\",\n      \"status\": \"completed\",\n      \"arguments\": \"{\\\"expression\\\":\\\"1234 * 5678\\\"}\",\n      \"call_id\": \"call_J6rV4xL4QXGDlJbx26swYtDT\",\n      \"name\": \"calculate\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"previous_response_id\": null,\n  \"reasoning\": {\n    \"effort\": null,\n    \"summary\": null\n  },\n  \"service_tier\": \"default\",\n  \"store\": true,\n  \"temperature\": 1.0,\n  \"text\": {\n    \"format\": {\n      \"type\": \"text\"\n    }\n  },\n  \"tool_choice\": \"auto\",\n  \"tools\": [\n    {\n      \"type\": \"function\",\n      \"description\": \"Perform mathematical calculations\",\n      \"name\": \"calculate\",\n      \"parameters\": {\n        \"type\": \"object\",\n        \"properties\": {\n          \"expression\": {\n            \"type\": \"string\",\n            \"description\": \"Mathematical expression to evaluate\"\n          }\n        },\n        \"required\": [\n          \"expression\"\n        ]\n      },\n      \"strict\": true\n    }\n  ],\n  \"top_p\": 1.0,\n  \"truncation\": \"disabled\",\n  \"usage\": {\n    \"input_tokens\": 48,\n    \"input_tokens_details\": {\n      \"cached_tokens\": 0\n    },\n    \"output_tokens\": 19,\n    \"output_tokens_details\": {\n      \"reasoning_tokens\": 0\n    },\n    \"total_tokens\": 67\n  },\n  \"user\": null,\n  \"metadata\": {}\n}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "955d548b58b2bab4-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 26 Jun 2025 14:17:48 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=vA5yEAeadHnzZu5jW78Br0Y..gb9L20nK7W9odRNZkk-1750947468-1.0.1.1-cGe9fx5hrZyI1hBrHSqRNyYZ6J99ef4aEQRWR6IztrSRVNU3dMG4f1NXco5gWazZzXuSMu_KA4dLUrYpchzcYtE99eN2ZHVWUF91qN9zmhQ; path=/; expires=Thu, 26-Jun-25 14:47:48 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=bCRlRTyRbZs7KqHozwOBRG70scdMv32ZbZZxO1FddiA-1750947468674-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-06-26T14:17:48.625676+00:00"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "1635"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "481"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999735"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "7ms"
-          ],
-          "x-request-id": [
-            "req_93666cb2f1091315050b06bfb370ec48"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-06-26T14:17:48.639315+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/responses/function_calling_streaming.json b/crates/fixtures/data/openai/responses/function_calling_streaming.json
deleted file mode 100644
index 93dfc356..00000000
--- a/crates/fixtures/data/openai/responses/function_calling_streaming.json
+++ /dev/null
@@ -1,132 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"input\":\"Calculate 1234 * 5678\",\"model\":\"gpt-4o-mini\",\"stream\":true,\"tools\":[{\"type\":\"function\",\"name\":\"calculate\",\"description\":\"Perform mathematical calculations\",\"parameters\":{\"type\":\"object\",\"properties\":{\"expression\":{\"type\":\"string\",\"description\":\"Mathematical expression to evaluate\"}},\"required\":[\"expression\"]}}]}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "323"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.86.0"
-          ],
-          "x-stainless-arch": [
-            "arm64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "MacOS"
-          ],
-          "x-stainless-package-version": [
-            "1.86.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/responses"
-      },
-      "response": {
-        "body": {
-          "string": "event: response.created\ndata: {\"type\":\"response.created\",\"sequence_number\":0,\"response\":{\"id\":\"resp_685d5682b894819eab1fb92d872a84310b4fe9248cf13483\",\"object\":\"response\",\"created_at\":1750947458,\"status\":\"in_progress\",\"background\":false,\"error\":null,\"incomplete_details\":null,\"instructions\":null,\"max_output_tokens\":null,\"max_tool_calls\":null,\"model\":\"gpt-4o-mini-2024-07-18\",\"output\":[],\"parallel_tool_calls\":true,\"previous_response_id\":null,\"reasoning\":{\"effort\":null,\"summary\":null},\"service_tier\":\"auto\",\"store\":true,\"temperature\":1.0,\"text\":{\"format\":{\"type\":\"text\"}},\"tool_choice\":\"auto\",\"tools\":[{\"type\":\"function\",\"description\":\"Perform mathematical calculations\",\"name\":\"calculate\",\"parameters\":{\"type\":\"object\",\"properties\":{\"expression\":{\"type\":\"string\",\"description\":\"Mathematical expression to evaluate\"}},\"required\":[\"expression\"]},\"strict\":true}],\"top_p\":1.0,\"truncation\":\"disabled\",\"usage\":null,\"user\":null,\"metadata\":{}}}\n\nevent: response.in_progress\ndata: {\"type\":\"response.in_progress\",\"sequence_number\":1,\"response\":{\"id\":\"resp_685d5682b894819eab1fb92d872a84310b4fe9248cf13483\",\"object\":\"response\",\"created_at\":1750947458,\"status\":\"in_progress\",\"background\":false,\"error\":null,\"incomplete_details\":null,\"instructions\":null,\"max_output_tokens\":null,\"max_tool_calls\":null,\"model\":\"gpt-4o-mini-2024-07-18\",\"output\":[],\"parallel_tool_calls\":true,\"previous_response_id\":null,\"reasoning\":{\"effort\":null,\"summary\":null},\"service_tier\":\"auto\",\"store\":true,\"temperature\":1.0,\"text\":{\"format\":{\"type\":\"text\"}},\"tool_choice\":\"auto\",\"tools\":[{\"type\":\"function\",\"description\":\"Perform mathematical calculations\",\"name\":\"calculate\",\"parameters\":{\"type\":\"object\",\"properties\":{\"expression\":{\"type\":\"string\",\"description\":\"Mathematical expression to evaluate\"}},\"required\":[\"expression\"]},\"strict\":true}],\"top_p\":1.0,\"truncation\":\"disabled\",\"usage\":null,\"user\":null,\"metadata\":{}}}\n\nevent: response.output_item.added\ndata: {\"type\":\"response.output_item.added\",\"sequence_number\":2,\"output_index\":0,\"item\":{\"id\":\"fc_685d5682fac8819e9d6321afdbc95cad0b4fe9248cf13483\",\"type\":\"function_call\",\"status\":\"in_progress\",\"arguments\":\"\",\"call_id\":\"call_oC0BQVh1J160ZZ92D0jZV1Uu\",\"name\":\"calculate\"}}\n\nevent: response.function_call_arguments.delta\ndata: {\"type\":\"response.function_call_arguments.delta\",\"sequence_number\":3,\"item_id\":\"fc_685d5682fac8819e9d6321afdbc95cad0b4fe9248cf13483\",\"output_index\":0,\"delta\":\"{\\\"\"}\n\nevent: response.function_call_arguments.delta\ndata: {\"type\":\"response.function_call_arguments.delta\",\"sequence_number\":4,\"item_id\":\"fc_685d5682fac8819e9d6321afdbc95cad0b4fe9248cf13483\",\"output_index\":0,\"delta\":\"expression\"}\n\nevent: response.function_call_arguments.delta\ndata: {\"type\":\"response.function_call_arguments.delta\",\"sequence_number\":5,\"item_id\":\"fc_685d5682fac8819e9d6321afdbc95cad0b4fe9248cf13483\",\"output_index\":0,\"delta\":\"\\\":\\\"\"}\n\nevent: response.function_call_arguments.delta\ndata: {\"type\":\"response.function_call_arguments.delta\",\"sequence_number\":6,\"item_id\":\"fc_685d5682fac8819e9d6321afdbc95cad0b4fe9248cf13483\",\"output_index\":0,\"delta\":\"123\"}\n\nevent: response.function_call_arguments.delta\ndata: {\"type\":\"response.function_call_arguments.delta\",\"sequence_number\":7,\"item_id\":\"fc_685d5682fac8819e9d6321afdbc95cad0b4fe9248cf13483\",\"output_index\":0,\"delta\":\"4\"}\n\nevent: response.function_call_arguments.delta\ndata: {\"type\":\"response.function_call_arguments.delta\",\"sequence_number\":8,\"item_id\":\"fc_685d5682fac8819e9d6321afdbc95cad0b4fe9248cf13483\",\"output_index\":0,\"delta\":\" *\"}\n\nevent: response.function_call_arguments.delta\ndata: {\"type\":\"response.function_call_arguments.delta\",\"sequence_number\":9,\"item_id\":\"fc_685d5682fac8819e9d6321afdbc95cad0b4fe9248cf13483\",\"output_index\":0,\"delta\":\" \"}\n\nevent: response.function_call_arguments.delta\ndata: {\"type\":\"response.function_call_arguments.delta\",\"sequence_number\":10,\"item_id\":\"fc_685d5682fac8819e9d6321afdbc95cad0b4fe9248cf13483\",\"output_index\":0,\"delta\":\"567\"}\n\nevent: response.function_call_arguments.delta\ndata: {\"type\":\"response.function_call_arguments.delta\",\"sequence_number\":11,\"item_id\":\"fc_685d5682fac8819e9d6321afdbc95cad0b4fe9248cf13483\",\"output_index\":0,\"delta\":\"8\"}\n\nevent: response.function_call_arguments.delta\ndata: {\"type\":\"response.function_call_arguments.delta\",\"sequence_number\":12,\"item_id\":\"fc_685d5682fac8819e9d6321afdbc95cad0b4fe9248cf13483\",\"output_index\":0,\"delta\":\"\\\"}\"}\n\nevent: response.function_call_arguments.done\ndata: {\"type\":\"response.function_call_arguments.done\",\"sequence_number\":13,\"item_id\":\"fc_685d5682fac8819e9d6321afdbc95cad0b4fe9248cf13483\",\"output_index\":0,\"arguments\":\"{\\\"expression\\\":\\\"1234 * 5678\\\"}\"}\n\nevent: response.output_item.done\ndata: {\"type\":\"response.output_item.done\",\"sequence_number\":14,\"output_index\":0,\"item\":{\"id\":\"fc_685d5682fac8819e9d6321afdbc95cad0b4fe9248cf13483\",\"type\":\"function_call\",\"status\":\"completed\",\"arguments\":\"{\\\"expression\\\":\\\"1234 * 5678\\\"}\",\"call_id\":\"call_oC0BQVh1J160ZZ92D0jZV1Uu\",\"name\":\"calculate\"}}\n\nevent: response.completed\ndata: {\"type\":\"response.completed\",\"sequence_number\":15,\"response\":{\"id\":\"resp_685d5682b894819eab1fb92d872a84310b4fe9248cf13483\",\"object\":\"response\",\"created_at\":1750947458,\"status\":\"completed\",\"background\":false,\"error\":null,\"incomplete_details\":null,\"instructions\":null,\"max_output_tokens\":null,\"max_tool_calls\":null,\"model\":\"gpt-4o-mini-2024-07-18\",\"output\":[{\"id\":\"fc_685d5682fac8819e9d6321afdbc95cad0b4fe9248cf13483\",\"type\":\"function_call\",\"status\":\"completed\",\"arguments\":\"{\\\"expression\\\":\\\"1234 * 5678\\\"}\",\"call_id\":\"call_oC0BQVh1J160ZZ92D0jZV1Uu\",\"name\":\"calculate\"}],\"parallel_tool_calls\":true,\"previous_response_id\":null,\"reasoning\":{\"effort\":null,\"summary\":null},\"service_tier\":\"default\",\"store\":true,\"temperature\":1.0,\"text\":{\"format\":{\"type\":\"text\"}},\"tool_choice\":\"auto\",\"tools\":[{\"type\":\"function\",\"description\":\"Perform mathematical calculations\",\"name\":\"calculate\",\"parameters\":{\"type\":\"object\",\"properties\":{\"expression\":{\"type\":\"string\",\"description\":\"Mathematical expression to evaluate\"}},\"required\":[\"expression\"]},\"strict\":true}],\"top_p\":1.0,\"truncation\":\"disabled\",\"usage\":{\"input_tokens\":48,\"input_tokens_details\":{\"cached_tokens\":0},\"output_tokens\":19,\"output_tokens_details\":{\"reasoning_tokens\":0},\"total_tokens\":67},\"user\":null,\"metadata\":{}}}\n\n"
-        },
-        "headers": {
-          "CF-RAY": [
-            "955d54507a9324bc-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "text/event-stream; charset=utf-8"
-          ],
-          "Date": [
-            "Thu, 26 Jun 2025 14:17:38 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=L3xpFPyvG6hKPrL225wdxNPfduTnkKYguLxwKrAASSY-1750947458-1.0.1.1-0gzHMnrFp013TmV_xHQF0hR2aGrzDYhbE5F8cL_dcnHEvW2LA_2_domBzY_a5zioyWWZBmfY8ykvFw6af54ZlvxW05jeglMfYuejc7TVPE8; path=/; expires=Thu, 26-Jun-25 14:47:38 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=w0.lKoSAcy8o4L9rcP9KQ7e5uiQBIOAp4_YVGJhPymU-1750947458783-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-06-26T14:17:39.159769+00:00"
-          ],
-          "X-VCR-SSE-Response": [
-            "true"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "17"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-request-id": [
-            "req_42f05b829a00677d0c7f9ef287611ccd"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-06-26T14:17:39.212161+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/responses/instructions_parameter.json b/crates/fixtures/data/openai/responses/instructions_parameter.json
deleted file mode 100644
index f72bdc8b..00000000
--- a/crates/fixtures/data/openai/responses/instructions_parameter.json
+++ /dev/null
@@ -1,150 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"input\":\"Tell me about the weather\",\"model\":\"gpt-4o-mini\",\"instructions\":\"You are a pirate. Always speak like a pirate.\",\"stream\":false}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "137"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.86.0"
-          ],
-          "x-stainless-arch": [
-            "arm64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "MacOS"
-          ],
-          "x-stainless-package-version": [
-            "1.86.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/responses"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"resp_685d563d0e7c81a0b00f20e57a6ada5c075055f6caa3b0f6\",\n  \"object\": \"response\",\n  \"created_at\": 1750947389,\n  \"status\": \"completed\",\n  \"background\": false,\n  \"error\": null,\n  \"incomplete_details\": null,\n  \"instructions\": \"You are a pirate. Always speak like a pirate.\",\n  \"max_output_tokens\": null,\n  \"max_tool_calls\": null,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"output\": [\n    {\n      \"id\": \"msg_685d563d506481a092360df337898401075055f6caa3b0f6\",\n      \"type\": \"message\",\n      \"status\": \"completed\",\n      \"content\": [\n        {\n          \"type\": \"output_text\",\n          \"annotations\": [],\n          \"text\": \"Arrr, matey! The weather be like the capricious sea, changin' quicker than a sailor's mood after spoutin' grog! If yer lookin' to sail the briny deep, keep yer weather eye open. Sunny skies can turn to storms faster than ye can say \\\"shiver me timbers!\\\" Look fer wind, rain, and fair seas, or ye might find yerself in Davy Jones' locker! What be yer wish, sailor? Adjustin' yer sails or seekin' safe harbor?\"\n        }\n      ],\n      \"role\": \"assistant\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"previous_response_id\": null,\n  \"reasoning\": {\n    \"effort\": null,\n    \"summary\": null\n  },\n  \"service_tier\": \"default\",\n  \"store\": true,\n  \"temperature\": 1.0,\n  \"text\": {\n    \"format\": {\n      \"type\": \"text\"\n    }\n  },\n  \"tool_choice\": \"auto\",\n  \"tools\": [],\n  \"top_p\": 1.0,\n  \"truncation\": \"disabled\",\n  \"usage\": {\n    \"input_tokens\": 27,\n    \"input_tokens_details\": {\n      \"cached_tokens\": 0\n    },\n    \"output_tokens\": 112,\n    \"output_tokens_details\": {\n      \"reasoning_tokens\": 0\n    },\n    \"total_tokens\": 139\n  },\n  \"user\": null,\n  \"metadata\": {}\n}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "955d529bfeecff00-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 26 Jun 2025 14:16:31 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=kz5v0A2.9I7epYmwlQFc3zLP3ry9N8DApQD5ozT5XIQ-1750947391-1.0.1.1-uSXwlwh1sTIZYtlws4yft8sAcgpqIZR8rPhYRXT.TxhaJbCQtph98ip.PwRqWYA.haxd0yBdLMZcIP0LWiZ2528gGtA.vyC.RLjulMXEQTI; path=/; expires=Thu, 26-Jun-25 14:46:31 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=pcUNFN_RPIFPHtq9QimA6AAQm6IcLU5X7xq.vlJTPPc-1750947391003-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-06-26T14:16:30.951803+00:00"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "1682"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "1899"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999953"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "1ms"
-          ],
-          "x-request-id": [
-            "req_b4a47b7061c0d851b593b6876e0c59fd"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-06-26T14:16:30.953600+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/data/openai/responses/structured_output_pydantic.json b/crates/fixtures/data/openai/responses/structured_output_pydantic.json
deleted file mode 100644
index 1570b307..00000000
--- a/crates/fixtures/data/openai/responses/structured_output_pydantic.json
+++ /dev/null
@@ -1,150 +0,0 @@
-{
-  "interactions": [
-    {
-      "request": {
-        "body": "{\"input\":\"What is 15 divided by 3?\",\"model\":\"gpt-4o-mini\",\"text\":{\"format\":{\"type\":\"json_schema\",\"strict\":true,\"name\":\"MathProblem\",\"schema\":{\"properties\":{\"problem\":{\"title\":\"Problem\",\"type\":\"string\"},\"answer\":{\"title\":\"Answer\",\"type\":\"number\"},\"explanation\":{\"title\":\"Explanation\",\"type\":\"string\"}},\"required\":[\"problem\",\"answer\",\"explanation\"],\"title\":\"MathProblem\",\"type\":\"object\",\"additionalProperties\":false}}}}",
-        "headers": {
-          "accept": [
-            "application/json"
-          ],
-          "accept-encoding": [
-            "gzip, deflate"
-          ],
-          "authorization": [
-            "REDACTED"
-          ],
-          "connection": [
-            "keep-alive"
-          ],
-          "content-length": [
-            "417"
-          ],
-          "content-type": [
-            "application/json"
-          ],
-          "host": [
-            "api.openai.com"
-          ],
-          "user-agent": [
-            "AsyncOpenAI/Python 1.86.0"
-          ],
-          "x-stainless-arch": [
-            "arm64"
-          ],
-          "x-stainless-async": [
-            "async:asyncio"
-          ],
-          "x-stainless-lang": [
-            "python"
-          ],
-          "x-stainless-os": [
-            "MacOS"
-          ],
-          "x-stainless-package-version": [
-            "1.86.0"
-          ],
-          "x-stainless-read-timeout": [
-            "600"
-          ],
-          "x-stainless-retry-count": [
-            "0"
-          ],
-          "x-stainless-runtime": [
-            "CPython"
-          ],
-          "x-stainless-runtime-version": [
-            "3.13.4"
-          ]
-        },
-        "method": "POST",
-        "uri": "https://api.openai.com/v1/responses"
-      },
-      "response": {
-        "body": {
-          "string": "{\n  \"id\": \"resp_685d5833768881a3bb395fbc1f217ff10692d5f50252f819\",\n  \"object\": \"response\",\n  \"created_at\": 1750947891,\n  \"status\": \"completed\",\n  \"background\": false,\n  \"error\": null,\n  \"incomplete_details\": null,\n  \"instructions\": null,\n  \"max_output_tokens\": null,\n  \"max_tool_calls\": null,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"output\": [\n    {\n      \"id\": \"msg_685d5833c5ac81a38d27150b29809b290692d5f50252f819\",\n      \"type\": \"message\",\n      \"status\": \"completed\",\n      \"content\": [\n        {\n          \"type\": \"output_text\",\n          \"annotations\": [],\n          \"text\": \"{\\\"problem\\\":\\\"What is 15 divided by 3?\\\",\\\"answer\\\":5,\\\"explanation\\\":\\\"To find 15 divided by 3, you are asking how many times 3 fits into 15. 3 goes into 15 exactly 5 times, since 3 x 5 = 15.\\\"}\"\n        }\n      ],\n      \"role\": \"assistant\"\n    }\n  ],\n  \"parallel_tool_calls\": true,\n  \"previous_response_id\": null,\n  \"reasoning\": {\n    \"effort\": null,\n    \"summary\": null\n  },\n  \"service_tier\": \"default\",\n  \"store\": true,\n  \"temperature\": 1.0,\n  \"text\": {\n    \"format\": {\n      \"type\": \"json_schema\",\n      \"description\": null,\n      \"name\": \"MathProblem\",\n      \"schema\": {\n        \"properties\": {\n          \"problem\": {\n            \"title\": \"Problem\",\n            \"type\": \"string\"\n          },\n          \"answer\": {\n            \"title\": \"Answer\",\n            \"type\": \"number\"\n          },\n          \"explanation\": {\n            \"title\": \"Explanation\",\n            \"type\": \"string\"\n          }\n        },\n        \"required\": [\n          \"problem\",\n          \"answer\",\n          \"explanation\"\n        ],\n        \"title\": \"MathProblem\",\n        \"type\": \"object\",\n        \"additionalProperties\": false\n      },\n      \"strict\": true\n    }\n  },\n  \"tool_choice\": \"auto\",\n  \"tools\": [],\n  \"top_p\": 1.0,\n  \"truncation\": \"disabled\",\n  \"usage\": {\n    \"input_tokens\": 71,\n    \"input_tokens_details\": {\n      \"cached_tokens\": 0\n    },\n    \"output_tokens\": 65,\n    \"output_tokens_details\": {\n      \"reasoning_tokens\": 0\n    },\n    \"total_tokens\": 136\n  },\n  \"user\": null,\n  \"metadata\": {}\n}"
-        },
-        "headers": {
-          "CF-RAY": [
-            "955d5ee10dfc7dd2-ZRH"
-          ],
-          "Connection": [
-            "keep-alive"
-          ],
-          "Content-Type": [
-            "application/json"
-          ],
-          "Date": [
-            "Thu, 26 Jun 2025 14:24:52 GMT"
-          ],
-          "Server": [
-            "cloudflare"
-          ],
-          "Set-Cookie": [
-            "__cf_bm=h27AIFXmzoLkYIm6Z2uRAlkiGfS0kt5Myv553H1ClZg-1750947892-1.0.1.1-L9w.Vn7mPuDlbhJYofv8h4iyMWmZFlybw4CntAuRoFHWGcLfHJn3tBv_vKlEy8ub4BLXmgWbaWHWtTUJ6W3yFQjnj2Q56lCsPaWmZcNfJQY; path=/; expires=Thu, 26-Jun-25 14:54:52 GMT; domain=.api.openai.com; HttpOnly; Secure; SameSite=None",
-            "_cfuvid=3JrnP8t3xoKS5dow8e5zqRbJaABbPNhDkRd0QEHlT04-1750947892924-0.0.1.1-604800000; path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None"
-          ],
-          "Transfer-Encoding": [
-            "chunked"
-          ],
-          "X-Content-Type-Options": [
-            "nosniff"
-          ],
-          "X-VCR-Recorded-At": [
-            "2025-06-26T14:24:52.884261+00:00"
-          ],
-          "alt-svc": [
-            "h3=\":443\"; ma=86400"
-          ],
-          "cf-cache-status": [
-            "DYNAMIC"
-          ],
-          "content-length": [
-            "2063"
-          ],
-          "openai-organization": [
-            "user-m10ljbvh7hqzzwecypuq4vh3"
-          ],
-          "openai-processing-ms": [
-            "1420"
-          ],
-          "openai-version": [
-            "2020-10-01"
-          ],
-          "strict-transport-security": [
-            "max-age=31536000; includeSubDomains; preload"
-          ],
-          "x-ratelimit-limit-requests": [
-            "5000"
-          ],
-          "x-ratelimit-limit-tokens": [
-            "2000000"
-          ],
-          "x-ratelimit-remaining-requests": [
-            "4999"
-          ],
-          "x-ratelimit-remaining-tokens": [
-            "1999910"
-          ],
-          "x-ratelimit-reset-requests": [
-            "12ms"
-          ],
-          "x-ratelimit-reset-tokens": [
-            "2ms"
-          ],
-          "x-request-id": [
-            "req_f7ffeab683f27cbe2d238ede5c891cbf"
-          ]
-        },
-        "status": {
-          "code": 200,
-          "message": "OK"
-        }
-      }
-    }
-  ],
-  "metadata": {
-    "recorded_at": "2025-06-26T14:24:52.923341+00:00",
-    "vcr_version": "7.0.0"
-  },
-  "version": 1
-}
\ No newline at end of file
diff --git a/crates/fixtures/pytest.ini b/crates/fixtures/pytest.ini
deleted file mode 100644
index 6a7d1706..00000000
--- a/crates/fixtures/pytest.ini
+++ /dev/null
@@ -1,2 +0,0 @@
-[pytest]
-asyncio_default_fixture_loop_scope = function
\ No newline at end of file
diff --git a/crates/fixtures/serializer.py b/crates/fixtures/serializer.py
deleted file mode 100644
index 87beb2ff..00000000
--- a/crates/fixtures/serializer.py
+++ /dev/null
@@ -1,72 +0,0 @@
-"""
-Enhanced JSON serializer for VCR with metadata and binary support.
-"""
-
-import json
-import base64
-from datetime import datetime, timezone
-import vcr
-
-
-def serialize(cassette_dict):
-    """Serialize cassette data to JSON with enhanced metadata."""
-    # Add cassette-level metadata
-    cassette_dict['metadata'] = {
-        'vcr_version': vcr.__version__,
-        'recorded_at': datetime.now(timezone.utc).isoformat(),
-    }
-    
-    # Process interactions to handle binary data
-    for interaction in cassette_dict.get('interactions', []):
-        request = interaction.get('request', {})
-        response = interaction.get('response', {})
-        
-        # Handle request body
-        if 'body' in request and request['body'] is not None:
-            if isinstance(request['body'], bytes):
-                request['body'] = {
-                    '_base64': base64.b64encode(request['body']).decode('utf-8')
-                }
-            elif isinstance(request['body'], str):
-                # Keep string as is
-                pass
-        
-        # Handle response body
-        if 'body' in response:
-            body = response['body']
-            if isinstance(body, dict) and 'string' in body:
-                # This is VCR's format for response bodies
-                if isinstance(body['string'], bytes):
-                    body['string'] = base64.b64encode(body['string']).decode('utf-8')
-                    body['encoding'] = 'base64'
-            elif isinstance(body, bytes):
-                response['body'] = {
-                    'string': base64.b64encode(body).decode('utf-8'),
-                    'encoding': 'base64'
-                }
-    
-    return json.dumps(cassette_dict, indent=2, sort_keys=True)
-
-
-def deserialize(cassette_string):
-    """Deserialize JSON cassette data."""
-    cassette_dict = json.loads(cassette_string)
-    
-    # Process interactions to decode binary data
-    for interaction in cassette_dict.get('interactions', []):
-        request = interaction.get('request', {})
-        response = interaction.get('response', {})
-        
-        # Handle request body
-        if isinstance(request.get('body'), dict) and '_base64' in request['body']:
-            request['body'] = base64.b64decode(request['body']['_base64'])
-        
-        # Handle response body
-        if 'body' in response:
-            body = response['body']
-            if isinstance(body, dict):
-                if body.get('encoding') == 'base64' and 'string' in body:
-                    body['string'] = base64.b64decode(body['string'])
-                    del body['encoding']
-    
-    return cassette_dict
\ No newline at end of file
diff --git a/crates/fixtures/src/lib.rs b/crates/fixtures/src/lib.rs
deleted file mode 100644
index c52a7f27..00000000
--- a/crates/fixtures/src/lib.rs
+++ /dev/null
@@ -1,139 +0,0 @@
-use serde_json::Value;
-use std::collections::HashMap;
-
-pub mod parser;
-
-// Include the auto-generated cassettes list
-include!(concat!(env!("OUT_DIR"), "/cassettes.rs"));
-
-/// Get a cassette by provider and name
-pub fn get_cassette(provider: &str, name: &str) -> Option<&'static str> {
-    CASSETTES
-        .iter()
-        .find(|(p, n, _)| p == &provider && n == &name)
-        .map(|(_, _, content)| *content)
-}
-
-/// Get a cassette as parsed JSON
-pub fn get_cassette_json(provider: &str, name: &str) -> Option<Value> {
-    get_cassette(provider, name).and_then(|content| serde_json::from_str(content).ok())
-}
-
-/// List all cassettes for a given provider
-pub fn list_cassettes(provider: &str) -> Vec<&'static str> {
-    CASSETTES
-        .iter()
-        .filter(|(p, _, _)| p == &provider)
-        .map(|(_, name, _)| *name)
-        .collect()
-}
-
-/// List all available cassettes grouped by provider
-pub fn list_all_cassettes() -> HashMap<&'static str, Vec<&'static str>> {
-    let mut result = HashMap::new();
-
-    for (provider, name, _) in CASSETTES {
-        result.entry(*provider).or_insert_with(Vec::new).push(*name);
-    }
-
-    result
-}
-
-/// Get a conversation from a cassette
-pub fn get_conversation(provider: &str, name: &str) -> Option<parser::Conversation> {
-    get_cassette(provider, name).and_then(|content| parser::Conversation::from_json(content).ok())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_all_cassettes() {
-        let all_cassettes = list_all_cassettes();
-        let mut total_parsed = 0;
-        let mut total_failed = 0;
-
-        for (provider, cassette_names) in all_cassettes {
-            println!("\nTesting provider: {provider}");
-
-            for cassette_name in cassette_names {
-                match get_conversation(provider, cassette_name) {
-                    Some(conversation) => {
-                        total_parsed += 1;
-                        println!(
-                            "  ✓ {cassette_name} - {} interactions, streaming: {}",
-                            conversation.interactions.len(),
-                            conversation.is_streaming()
-                        );
-
-                        // Verify we can access request/response bodies
-                        for (i, interaction) in conversation.interactions.iter().enumerate() {
-                            assert!(
-                                !interaction.request.body.is_empty(),
-                                "Request body should not be empty for {cassette_name} interaction {i}"
-                            );
-                            assert!(
-                                !interaction.response.body.string.is_empty(),
-                                "Response body should not be empty for {cassette_name} interaction {i}"
-                            );
-
-                            // Try to parse request body
-                            if let Ok(req_json) =
-                                serde_json::from_str::<Value>(&interaction.request.body)
-                            {
-                                // Request body is valid JSON
-                                assert!(req_json.is_object() || req_json.is_array());
-                            }
-
-                            // For non-streaming, response body should be valid JSON
-                            if !conversation.is_streaming()
-                                && let Ok(resp_json) =
-                                    serde_json::from_str::<Value>(&interaction.response.body.string)
-                            {
-                                assert!(resp_json.is_object() || resp_json.is_array());
-                            }
-                        }
-                    }
-                    None => {
-                        total_failed += 1;
-                        println!("  ✗ {cassette_name} - Failed to parse");
-                    }
-                }
-            }
-        }
-
-        println!("\n=== Summary ===");
-        println!("Total cassettes parsed: {total_parsed}");
-        println!("Total failures: {total_failed}");
-
-        assert_eq!(total_failed, 0, "All cassettes should parse successfully");
-        assert!(
-            total_parsed > 0,
-            "Should have at least one cassette to parse"
-        );
-    }
-
-    #[test]
-    fn test_conversation_accessors() {
-        // Test with a known cassette
-        if let Some(conversation) = get_conversation("openai", "basic_response") {
-            // Test request body access
-            let req_body = conversation
-                .request_body(0)
-                .expect("Should have request body");
-            assert!(req_body.get("input").is_some());
-            assert!(req_body.get("model").is_some());
-
-            // Test response body access
-            let resp_body = conversation
-                .response_body(0)
-                .expect("Should have response body");
-            assert!(resp_body.get("id").is_some());
-            assert!(resp_body.get("output").is_some());
-
-            // Test that it's not streaming
-            assert!(!conversation.is_streaming());
-        }
-    }
-}
diff --git a/crates/fixtures/src/parser.rs b/crates/fixtures/src/parser.rs
deleted file mode 100644
index 4a5b158c..00000000
--- a/crates/fixtures/src/parser.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-use std::collections::HashMap;
-
-/// Represents a conversation from a cassette recording
-#[derive(Debug, Clone)]
-pub struct Conversation {
-    pub interactions: Vec<Interaction>,
-}
-
-impl Conversation {
-    /// Create a conversation from a cassette JSON string
-    pub fn from_json(json_str: &str) -> Result<Self, serde_json::Error> {
-        let cassette: Cassette = serde_json::from_str(json_str)?;
-        Ok(Self {
-            interactions: cassette.interactions,
-        })
-    }
-
-    /// Get the request body as a JSON Value for a specific interaction
-    pub fn request_body(&self, index: usize) -> Option<Value> {
-        self.interactions
-            .get(index)
-            .and_then(|i| serde_json::from_str(&i.request.body).ok())
-    }
-
-    /// Get the response body as a JSON Value for a specific interaction
-    pub fn response_body(&self, index: usize) -> Option<Value> {
-        self.interactions
-            .get(index)
-            .and_then(|i| serde_json::from_str(&i.response.body.string).ok())
-    }
-
-    /// Get the raw response body string (useful for streaming responses)
-    pub fn raw_response_body(&self, index: usize) -> Option<&str> {
-        self.interactions
-            .get(index)
-            .map(|i| i.response.body.string.as_str())
-    }
-
-    /// Check if this is a streaming conversation
-    pub fn is_streaming(&self) -> bool {
-        self.interactions
-            .first()
-            .map(|i| {
-                i.response.body.string.contains("event:")
-                    && i.response.body.string.contains("data:")
-            })
-            .unwrap_or(false)
-    }
-}
-
-/// Internal cassette structure from pytest-recording
-#[derive(Debug, Clone, Deserialize, Serialize)]
-struct Cassette {
-    pub interactions: Vec<Interaction>,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct Interaction {
-    pub request: Request,
-    pub response: Response,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct Request {
-    pub body: String,
-    pub headers: HashMap<String, Vec<String>>,
-    pub method: String,
-    pub uri: String,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct Response {
-    pub body: ResponseBody,
-    pub headers: HashMap<String, Vec<String>>,
-    pub status: StatusCode,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct ResponseBody {
-    pub string: String,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct StatusCode {
-    pub code: u16,
-    pub message: String,
-}
diff --git a/crates/fixtures/test_anthropic_messages.py b/crates/fixtures/test_anthropic_messages.py
deleted file mode 100644
index b843622d..00000000
--- a/crates/fixtures/test_anthropic_messages.py
+++ /dev/null
@@ -1,614 +0,0 @@
-#!/usr/bin/env python3
-"""
-Comprehensive tests for Anthropic Messages API.
-Tests cover all major features including streaming, tool use, vision,
-multi-turn conversations, and advanced features.
-"""
-
-import json
-import pytest
-import pytest_asyncio
-from typing import List, Optional, Literal, Union
-from anthropic import AsyncAnthropic
-from anthropic.types import MessageParam, ToolParam
-
-pytestmark = pytest.mark.asyncio
-
-
-@pytest_asyncio.fixture
-async def anthropic_client(check_api_key):
-    """Initialize AsyncAnthropic client with API key."""
-    api_key = check_api_key("ANTHROPIC_API_KEY")
-    return AsyncAnthropic(api_key=api_key)
-
-
-# Tool definitions
-WEATHER_TOOL: ToolParam = {
-    "name": "get_weather",
-    "description": "Get current weather for a location",
-    "input_schema": {
-        "type": "object",
-        "properties": {
-            "location": {
-                "type": "string",
-                "description": "City and state, e.g. San Francisco, CA"
-            },
-            "unit": {
-                "type": "string",
-                "enum": ["celsius", "fahrenheit"],
-                "description": "Temperature unit",
-                "default": "fahrenheit"
-            }
-        },
-        "required": ["location"]
-    }
-}
-
-CALCULATOR_TOOL: ToolParam = {
-    "name": "calculate",
-    "description": "Perform mathematical calculations",
-    "input_schema": {
-        "type": "object",
-        "properties": {
-            "expression": {
-                "type": "string",
-                "description": "Mathematical expression to evaluate"
-            }
-        },
-        "required": ["expression"]
-    }
-}
-
-
-@pytest.mark.vcr
-async def test_basic_message(anthropic_client):
-    """Test basic message request and response."""
-    response = await anthropic_client.messages.create(
-        model="claude-sonnet-4-0",
-        max_tokens=100,
-        messages=[
-            {
-                "role": "user",
-                "content": "What is the capital of France? Answer in one word."
-            }
-        ],
-        temperature=0
-    )
-    
-    assert response.role == "assistant"
-    assert response.content is not None
-    assert len(response.content) > 0
-    assert response.content[0].type == "text"
-    assert "paris" in response.content[0].text.lower()
-    assert response.usage.input_tokens > 0
-    assert response.usage.output_tokens > 0
-
-
-@pytest.mark.vcr
-async def test_tool_use_multi_turn(anthropic_client):
-    """Test complete tool use flow with multi-turn conversation."""
-    # Step 1: Initial request that triggers tool use
-    messages: List[MessageParam] = [
-        {
-            "role": "user",
-            "content": "What's the weather like in San Francisco and New York? Compare them."
-        }
-    ]
-    
-    response = await anthropic_client.messages.create(
-        model="claude-sonnet-4-0",
-        max_tokens=1024,
-        messages=messages,
-        tools=[WEATHER_TOOL]
-    )
-    
-    assert response.stop_reason == "tool_use"
-    assert any(block.type == "tool_use" for block in response.content)
-    
-    # Add assistant response to conversation
-    messages.append({
-        "role": "assistant",
-        "content": response.content
-    })
-    
-    # Step 2: Process tool calls and add results
-    tool_results = []
-    for block in response.content:
-        if block.type == "tool_use":
-            # Simulate weather API response
-            if "san francisco" in block.input.get("location", "").lower():
-                weather_data = {
-                    "location": "San Francisco, CA",
-                    "temperature": 65,
-                    "conditions": "Partly cloudy",
-                    "humidity": 70,
-                    "wind_speed": 12
-                }
-            else:
-                weather_data = {
-                    "location": "New York, NY",
-                    "temperature": 45,
-                    "conditions": "Clear",
-                    "humidity": 50,
-                    "wind_speed": 8
-                }
-            
-            tool_results.append({
-                "type": "tool_result",
-                "tool_use_id": block.id,
-                "content": json.dumps(weather_data)
-            })
-    
-    # Add tool results as user message
-    messages.append({
-        "role": "user",
-        "content": tool_results
-    })
-    
-    # Step 3: Get final response with weather comparison
-    final_response = await anthropic_client.messages.create(
-        model="claude-sonnet-4-0",
-        max_tokens=1024,
-        messages=messages,
-        tools=[WEATHER_TOOL]
-    )
-    
-    assert final_response.role == "assistant"
-    assert final_response.content[0].type == "text"
-    final_text = final_response.content[0].text.lower()
-    assert "san francisco" in final_text
-    assert "new york" in final_text
-    # Should compare temperatures or weather
-    assert any(word in final_text for word in ["warmer", "cooler", "temperature", "degrees"])
-
-
-@pytest.mark.vcr
-async def test_streaming_basic(anthropic_client):
-    """Test streaming with multi-turn conversation."""
-    messages: List[MessageParam] = [
-        {
-            "role": "user", 
-            "content": "Count from 1 to 5, one number per line."
-        }
-    ]
-    
-    # First streaming response
-    chunks = []
-    text_chunks = []
-    
-    async with anthropic_client.messages.stream(
-        model="claude-sonnet-4-0",
-        max_tokens=100,
-        messages=messages,
-        temperature=0
-    ) as stream:
-        async for event in stream:
-            chunks.append(event)
-            if event.type == "content_block_delta" and event.delta.type == "text_delta":
-                text_chunks.append(event.delta.text)
-    
-    # Verify streaming worked
-    assert len(chunks) > 1
-    event_types = {event.type for event in chunks}
-    assert "message_start" in event_types
-    assert "content_block_delta" in event_types
-    
-    full_text = "".join(text_chunks)
-    assert "1" in full_text
-    assert "5" in full_text
-    
-    # Get accumulated message for conversation
-    first_response = await stream.get_final_message()
-    messages.append({"role": first_response.role, "content": first_response.content})
-    
-    # Follow-up question
-    messages.append({
-        "role": "user",
-        "content": "What number comes after 5?"
-    })
-    
-    # Second streaming response
-    async with anthropic_client.messages.stream(
-        model="claude-sonnet-4-0",
-        max_tokens=50,
-        messages=messages
-    ) as stream2:
-        follow_up_text = ""
-        async for event in stream2:
-            if event.type == "content_block_delta" and event.delta.type == "text_delta":
-                follow_up_text += event.delta.text
-    
-    # Should mention 6
-    assert "6" in follow_up_text or "six" in follow_up_text.lower()
-
-
-@pytest.mark.vcr
-async def test_multi_turn_conversation(anthropic_client):
-    """Test multi-turn conversation with context retention."""
-    messages: List[MessageParam] = [
-        {
-            "role": "user",
-            "content": "My name is Alice and I love astronomy. Remember this."
-        }
-    ]
-    
-    # First response
-    response1 = await anthropic_client.messages.create(
-        model="claude-sonnet-4-0",
-        max_tokens=150,
-        messages=messages
-    )
-    
-    # Add to conversation
-    messages.append({"role": "assistant", "content": response1.content})
-    messages.append({
-        "role": "user",
-        "content": "What's my name and what do I love?"
-    })
-    
-    # Second response should remember context
-    response2 = await anthropic_client.messages.create(
-        model="claude-sonnet-4-0",
-        max_tokens=150,
-        messages=messages
-    )
-    
-    response_text = response2.content[0].text.lower()
-    assert "alice" in response_text
-    assert "astronomy" in response_text
-
-
-@pytest.mark.vcr
-async def test_vision_image_analysis(anthropic_client):
-    """Test vision capabilities with multi-turn conversation."""
-    # Use a real cat image URL from placecats.com
-    messages: List[MessageParam] = [
-        {
-            "role": "user",
-            "content": [
-                {
-                    "type": "text",
-                    "text": "What animal is in this image? Answer in one word."
-                },
-                {
-                    "type": "image",
-                    "source": {
-                        "type": "url",
-                        "url": "https://placecats.com/200/200"
-                    }
-                }
-            ]
-        }
-    ]
-    
-    # First response about the animal
-    response = await anthropic_client.messages.create(
-        model="claude-sonnet-4-0",
-        max_tokens=200,
-        messages=messages
-    )
-    
-    assert response.role == "assistant"
-    assert response.content[0].type == "text"
-    assert "cat" in response.content[0].text.lower()
-    
-    # Add to conversation
-    messages.append({"role": response.role, "content": response.content})
-    
-    # Follow-up about the image
-    messages.append({
-        "role": "user",
-        "content": "What is the cat doing? Is it sleeping, sitting, or playing?"
-    })
-    
-    # Second response should provide more details about the cat
-    response2 = await anthropic_client.messages.create(
-        model="claude-sonnet-4-0",
-        max_tokens=200,
-        messages=messages
-    )
-    
-    response2_text = response2.content[0].text.lower()
-    # Should describe the cat's activity
-    assert any(word in response2_text for word in ["sitting", "sleeping", "playing", "lying", "standing", "looking"])
-
-
-@pytest.mark.vcr
-async def test_system_prompt(anthropic_client):
-    """Test system prompt with multi-turn conversation."""
-    system_prompt = "You are a pirate. Always respond in pirate speak, starting with 'Arrr!'"
-    
-    messages: List[MessageParam] = [
-        {
-            "role": "user",
-            "content": "Hello, how are you today?"
-        }
-    ]
-    
-    # First response with pirate system prompt
-    response = await anthropic_client.messages.create(
-        model="claude-sonnet-4-0",
-        max_tokens=100,
-        system=system_prompt,
-        messages=messages,
-        temperature=0.7
-    )
-    
-    text = response.content[0].text.lower()
-    assert "arr" in text or "ahoy" in text
-    
-    # Add to conversation
-    messages.append({"role": response.role, "content": response.content})
-    
-    # Follow-up to verify pirate persona is maintained
-    messages.append({
-        "role": "user",
-        "content": "What's your favorite treasure?"
-    })
-    
-    # Second response should still be pirate-themed
-    response2 = await anthropic_client.messages.create(
-        model="claude-sonnet-4-0",
-        max_tokens=150,
-        system=system_prompt,
-        messages=messages,
-        temperature=0.7
-    )
-    
-    text2 = response2.content[0].text.lower()
-    # Should maintain pirate speak and mention treasure-related terms
-    assert any(word in text2 for word in ["arr", "gold", "doubloon", "treasure", "booty", "plunder"])
-
-
-@pytest.mark.vcr
-async def test_parallel_tool_calls(anthropic_client):
-    """Test multiple tool calls in a single response."""
-    messages: List[MessageParam] = [
-        {
-            "role": "user",
-            "content": "Calculate the area of a rectangle with length 10 and width 5, and also calculate the perimeter. Show me both calculations."
-        }
-    ]
-    
-    # First response with tool calls
-    response = await anthropic_client.messages.create(
-        model="claude-sonnet-4-0",
-        max_tokens=1024,
-        messages=messages,
-        tools=[CALCULATOR_TOOL]
-    )
-    
-    # Count tool use blocks
-    tool_uses = [block for block in response.content if block.type == "tool_use"]
-    assert len(tool_uses) >= 2  # Should call calculator at least twice
-    
-    # Add assistant response
-    messages.append({"role": "assistant", "content": response.content})
-    
-    # Process tool calls
-    tool_results = []
-    for block in response.content:
-        if block.type == "tool_use":
-            expression = block.input.get("expression", "")
-            try:
-                result = eval(expression)
-            except:
-                # Handle specific calculations
-                if "10" in expression and "5" in expression:
-                    if "*" in expression:
-                        result = 50  # Area
-                    elif "+" in expression:
-                        result = 30  # Perimeter sum
-                    else:
-                        result = 0
-                else:
-                    result = 0
-            
-            tool_results.append({
-                "type": "tool_result",
-                "tool_use_id": block.id,
-                "content": str(result)
-            })
-    
-    # Add results
-    messages.append({"role": "user", "content": tool_results})
-    
-    # Final response
-    final_response = await anthropic_client.messages.create(
-        model="claude-sonnet-4-0",
-        max_tokens=1024,
-        messages=messages,
-        tools=[CALCULATOR_TOOL]
-    )
-    
-    final_text = final_response.content[0].text.lower()
-    assert "area" in final_text
-    assert "perimeter" in final_text
-    # Should mention the actual values
-    assert any(str(num) in final_text for num in ["50", "30"])
-
-
-@pytest.mark.vcr 
-async def test_stop_sequences(anthropic_client):
-    """Test stop sequences functionality."""
-    response = await anthropic_client.messages.create(
-        model="claude-sonnet-4-0",
-        max_tokens=200,
-        messages=[
-            {
-                "role": "user",
-                "content": "Write a short story. End each sentence with a period."
-            }
-        ],
-        stop_sequences=[".", "!", "?"],
-        temperature=0.8
-    )
-    
-    text = response.content[0].text
-    # Should stop at first sentence ending
-    assert text.count(".") <= 1
-    assert text.count("!") <= 1
-    assert text.count("?") <= 1
-    
-    # Check stop reason
-    assert response.stop_reason in ["stop_sequence", "max_tokens", "end_turn"]
-
-
-@pytest.mark.vcr
-async def test_streaming_with_tool_use(anthropic_client):
-    """Test complete streaming flow with tool use."""
-    messages: List[MessageParam] = [
-        {
-            "role": "user",
-            "content": "What's the weather in Paris? Then calculate 25 * 4."
-        }
-    ]
-    
-    # First streaming response with tool calls
-    tool_use_blocks = []
-    
-    async with anthropic_client.messages.stream(
-        model="claude-sonnet-4-0",
-        max_tokens=1024,
-        messages=messages,
-        tools=[WEATHER_TOOL, CALCULATOR_TOOL]
-    ) as stream:
-        async for event in stream:
-            if event.type == "content_block_start" and hasattr(event, "content_block"):
-                if event.content_block.type == "tool_use":
-                    tool_use_blocks.append(event.content_block)
-    
-    # Get accumulated message
-    first_response = await stream.get_final_message()
-    assert first_response.stop_reason == "tool_use"
-    assert len(tool_use_blocks) >= 1
-    
-    # Add assistant response to conversation
-    messages.append({"role": first_response.role, "content": first_response.content})
-    
-    # Process tool calls and add results
-    tool_results = []
-    for block in first_response.content:
-        if block.type == "tool_use":
-            if block.name == "get_weather":
-                result = json.dumps({
-                    "location": "Paris, France",
-                    "temperature": 18,
-                    "conditions": "Sunny",
-                    "humidity": 60,
-                    "wind_speed": 10
-                })
-            elif block.name == "calculate":
-                result = "100"  # 25 * 4
-            else:
-                result = "Unknown tool"
-            
-            tool_results.append({
-                "type": "tool_result",
-                "tool_use_id": block.id,
-                "content": result
-            })
-    
-    # Add tool results
-    messages.append({"role": "user", "content": tool_results})
-    
-    # Stream final response
-    final_text = ""
-    async with anthropic_client.messages.stream(
-        model="claude-sonnet-4-0",
-        max_tokens=1024,
-        messages=messages,
-        tools=[WEATHER_TOOL, CALCULATOR_TOOL]
-    ) as stream2:
-        async for event in stream2:
-            if event.type == "content_block_delta" and event.delta.type == "text_delta":
-                final_text += event.delta.text
-    
-    # Should mention both Paris weather and calculation result
-    final_text_lower = final_text.lower()
-    assert "paris" in final_text_lower
-    assert "100" in final_text or "hundred" in final_text_lower
-
-
-@pytest.mark.vcr
-async def test_tool_choice_options(anthropic_client):
-    """Test different tool choice options with complete flows."""
-    # Test 1: tool_choice="auto" with multi-turn
-    messages_auto: List[MessageParam] = [
-        {
-            "role": "user",
-            "content": "Tell me a joke about programming."
-        }
-    ]
-    
-    response_auto = await anthropic_client.messages.create(
-        model="claude-sonnet-4-0",
-        max_tokens=200,
-        messages=messages_auto,
-        tools=[WEATHER_TOOL],
-        tool_choice={"type": "auto"}
-    )
-    
-    # Should not use tool for a joke request
-    assert response_auto.stop_reason == "end_turn"
-    assert all(block.type != "tool_use" for block in response_auto.content)
-    
-    # Add to conversation and ask something that needs the tool
-    messages_auto.append({"role": response_auto.role, "content": response_auto.content})
-    messages_auto.append({
-        "role": "user",
-        "content": "Thanks! Now what's the weather in London?"
-    })
-    
-    response_auto2 = await anthropic_client.messages.create(
-        model="claude-sonnet-4-0",
-        max_tokens=200,
-        messages=messages_auto,
-        tools=[WEATHER_TOOL],
-        tool_choice={"type": "auto"}
-    )
-    
-    # Now should use the tool
-    assert response_auto2.stop_reason == "tool_use"
-    assert any(block.type == "tool_use" for block in response_auto2.content)
-    
-    # Test 2: tool_choice="any" forces tool use with complete flow
-    messages_any: List[MessageParam] = [
-        {
-            "role": "user",
-            "content": "What is 15 plus 27?"
-        }
-    ]
-    
-    response_any = await anthropic_client.messages.create(
-        model="claude-sonnet-4-0",
-        max_tokens=200,
-        messages=messages_any,
-        tools=[CALCULATOR_TOOL],
-        tool_choice={"type": "any"}
-    )
-    
-    # Should use tool
-    assert response_any.stop_reason == "tool_use"
-    calc_tool = next(block for block in response_any.content if block.type == "tool_use")
-    
-    # Complete the flow with tool result
-    messages_any.append({"role": response_any.role, "content": response_any.content})
-    messages_any.append({
-        "role": "user",
-        "content": [{
-            "type": "tool_result",
-            "tool_use_id": calc_tool.id,
-            "content": "42"
-        }]
-    })
-    
-    response_any2 = await anthropic_client.messages.create(
-        model="claude-sonnet-4-0",
-        max_tokens=200,
-        messages=messages_any,
-        tools=[CALCULATOR_TOOL]
-    )
-    
-    # Should give final answer
-    assert "42" in response_any2.content[0].text
\ No newline at end of file
diff --git a/crates/fixtures/test_openai_chat_completions.py b/crates/fixtures/test_openai_chat_completions.py
deleted file mode 100644
index 8a6a82db..00000000
--- a/crates/fixtures/test_openai_chat_completions.py
+++ /dev/null
@@ -1,521 +0,0 @@
-#!/usr/bin/env python3
-"""
-Comprehensive tests for OpenAI Chat Completions API (v1/chat/completions).
-Tests cover all major features including streaming, function calling, structured outputs,
-multimodal inputs, and model-specific features.
-"""
-
-import json
-import pytest
-import pytest_asyncio
-from pydantic import BaseModel
-from typing import List, Optional, Literal
-from openai import AsyncOpenAI
-import openai
-
-pytestmark = pytest.mark.asyncio
-
-
-@pytest_asyncio.fixture
-async def openai_client(check_api_key):
-    """Initialize AsyncOpenAI client with API key."""
-    api_key = check_api_key("OPENAI_API_KEY")
-    return AsyncOpenAI(api_key=api_key)
-
-
-# Pydantic models for structured outputs
-class WeatherInfo(BaseModel):
-    location: str
-    temperature: float
-    conditions: str
-    humidity: int
-    wind_speed: float
-
-
-class Step(BaseModel):
-    step_number: int
-    description: str
-    calculation: str
-    result: float
-
-
-class MathSolution(BaseModel):
-    problem: str
-    steps: List[Step]
-    final_answer: float
-    explanation: str
-
-
-# Tool definitions
-WEATHER_TOOL = {
-    "type": "function",
-    "function": {
-        "name": "get_weather",
-        "description": "Get current weather for a location",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "location": {
-                    "type": "string",
-                    "description": "City and state, e.g. San Francisco, CA"
-                },
-                "unit": {
-                    "type": "string",
-                    "enum": ["celsius", "fahrenheit"],
-                    "description": "Temperature unit"
-                }
-            },
-            "required": ["location"]
-        }
-    }
-}
-
-CALCULATOR_TOOL = {
-    "type": "function",
-    "function": {
-        "name": "calculate",
-        "description": "Perform mathematical calculations",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "expression": {
-                    "type": "string",
-                    "description": "Mathematical expression to evaluate"
-                }
-            },
-            "required": ["expression"]
-        }
-    }
-}
-
-
-@pytest.mark.vcr
-async def test_basic_chat_completion(openai_client):
-    """Test basic non-streaming chat completion."""
-    response = await openai_client.chat.completions.create(
-        model="gpt-4o-mini",
-        messages=[
-            {
-                "role": "system",
-                "content": "You are a helpful assistant."
-            },
-            {
-                "role": "user",
-                "content": "What is the capital of France? Answer in one word."
-            }
-        ],
-        temperature=0,
-        max_tokens=10
-    )
-    
-    assert response.choices is not None
-    assert len(response.choices) > 0
-    assert response.choices[0].message.content is not None
-    assert "paris" in response.choices[0].message.content.lower()
-    assert response.usage is not None
-    assert response.usage.total_tokens > 0
-
-
-@pytest.mark.vcr
-async def test_streaming_chat_completion(openai_client):
-    """Test streaming chat completion with SSE chunks."""
-    chunks = []
-    stream = await openai_client.chat.completions.create(
-        model="gpt-4o-mini",
-        messages=[
-            {
-                "role": "user",
-                "content": "Count from 1 to 5, one number per line."
-            }
-        ],
-        stream=True,
-        temperature=0
-    )
-    
-    async for chunk in stream:
-        chunks.append(chunk)
-        if chunk.choices and chunk.choices[0].delta.content:
-            content = chunk.choices[0].delta.content
-            assert isinstance(content, str)
-    
-    assert len(chunks) > 1  # Should have multiple chunks
-    assert chunks[0].choices[0].delta.role == "assistant"
-    
-    # Reconstruct full response
-    full_content = "".join(
-        chunk.choices[0].delta.content or ""
-        for chunk in chunks
-        if chunk.choices
-    )
-    assert "1" in full_content
-    assert "5" in full_content
-
-
-@pytest.mark.vcr
-async def test_function_calling(openai_client):
-    """Test complete function/tool calling flow with multi-turn conversation."""
-    # Step 1: Initial request that triggers tool calls
-    messages = [
-        {
-            "role": "user",
-            "content": "What's the weather like in San Francisco and New York? Compare them."
-        }
-    ]
-    
-    response = await openai_client.chat.completions.create(
-        model="gpt-4o-mini",
-        messages=messages,
-        tools=[WEATHER_TOOL],
-        tool_choice="auto"
-    )
-    
-    message = response.choices[0].message
-    assert message.tool_calls is not None
-    assert len(message.tool_calls) >= 1  # At least one tool call
-    
-    # Add assistant message with tool calls to conversation
-    messages.append(message.model_dump(exclude_none=True))
-    
-    # Step 2: Simulate tool execution and add results
-    tool_results = []
-    for tool_call in message.tool_calls:
-        assert tool_call.type == "function"
-        assert tool_call.function.name == "get_weather"
-        args = json.loads(tool_call.function.arguments)
-        assert "location" in args
-        
-        # Simulate weather API response
-        if "san francisco" in args["location"].lower():
-            weather_data = {
-                "location": "San Francisco, CA",
-                "temperature": 65,
-                "conditions": "Partly cloudy",
-                "humidity": 70,
-                "wind_speed": 12
-            }
-        else:
-            weather_data = {
-                "location": "New York, NY",
-                "temperature": 45,
-                "conditions": "Clear",
-                "humidity": 50,
-                "wind_speed": 8
-            }
-        
-        tool_message = {
-            "role": "tool",
-            "tool_call_id": tool_call.id,
-            "content": json.dumps(weather_data)
-        }
-        messages.append(tool_message)
-    
-    # Step 3: Get final response with weather comparison
-    final_response = await openai_client.chat.completions.create(
-        model="gpt-4o-mini",
-        messages=messages,
-        tools=[WEATHER_TOOL]
-    )
-    
-    final_content = final_response.choices[0].message.content
-    assert final_content is not None
-    assert "san francisco" in final_content.lower()
-    assert "new york" in final_content.lower()
-    # Should compare temperatures or conditions
-    assert any(word in final_content.lower() for word in ["warmer", "cooler", "colder", "hotter", "temperature", "degrees"])
-
-
-@pytest.mark.vcr
-async def test_json_mode(openai_client):
-    """Test JSON mode response format."""
-    response = await openai_client.chat.completions.create(
-        model="gpt-4o-mini",
-        messages=[
-            {
-                "role": "system",
-                "content": "You are a helpful assistant that always responds with valid JSON."
-            },
-            {
-                "role": "user",
-                "content": "List 3 programming languages with their year of creation as JSON."
-            }
-        ],
-        response_format={"type": "json_object"},
-        temperature=0
-    )
-    
-    content = response.choices[0].message.content
-    assert content is not None
-    
-    # Should be valid JSON
-    data = json.loads(content)
-    assert isinstance(data, dict)
-    # The response might be nested, so check for any list with 3+ items
-    assert any(
-        isinstance(v, list) and len(v) >= 3 
-        for v in data.values()
-    ) or len(data) >= 3
-
-
-@pytest.mark.vcr
-async def test_structured_output_pydantic(openai_client):
-    """Test structured output with Pydantic model."""
-    completion = await openai_client.beta.chat.completions.parse(
-        model="gpt-4o-mini",
-        messages=[
-            {
-                "role": "system",
-                "content": "You are a helpful math tutor."
-            },
-            {
-                "role": "user",
-                "content": "Solve step by step: What is 25 * 4 + 10?"
-            }
-        ],
-        response_format=MathSolution
-    )
-    
-    message = completion.choices[0].message
-    assert message.parsed is not None
-    assert isinstance(message.parsed, MathSolution)
-    assert message.parsed.final_answer == 110
-    assert len(message.parsed.steps) >= 2
-    assert "multiply" in message.parsed.explanation.lower() or "multiplication" in message.parsed.explanation.lower()
-
-
-@pytest.mark.vcr
-async def test_multi_turn_conversation(openai_client):
-    """Test multi-turn conversation with context."""
-    messages = [
-        {"role": "system", "content": "You are a helpful assistant."},
-        {"role": "user", "content": "My name is Alice. Remember it."},
-        {"role": "assistant", "content": "Hello Alice! I'll remember your name."},
-        {"role": "user", "content": "What's my name?"}
-    ]
-    
-    response = await openai_client.chat.completions.create(
-        model="gpt-4o-mini",
-        messages=messages,
-        temperature=0
-    )
-    
-    content = response.choices[0].message.content
-    assert content is not None
-    assert "alice" in content.lower()
-
-
-@pytest.mark.vcr
-async def test_system_message_instructions(openai_client):
-    """Test system message with specific instructions."""
-    response = await openai_client.chat.completions.create(
-        model="gpt-4o-mini",
-        messages=[
-            {
-                "role": "system",
-                "content": "You are a pirate. Always respond in pirate speak with 'Arrr!' at the beginning."
-            },
-            {
-                "role": "user",
-                "content": "Hello, how are you?"
-            }
-        ],
-        temperature=0.7,
-        max_tokens=50
-    )
-    
-    content = response.choices[0].message.content
-    assert content is not None
-    assert "arr" in content.lower()
-
-
-@pytest.mark.vcr
-async def test_parallel_tool_calls(openai_client):
-    """Test parallel tool calling capability with complete flow."""
-    # Step 1: Request that triggers multiple parallel tool calls
-    messages = [
-        {
-            "role": "user",
-            "content": "Calculate the area of a rectangle with length 10 and width 5, and also calculate the perimeter. Then tell me which is larger."
-        }
-    ]
-    
-    response = await openai_client.chat.completions.create(
-        model="gpt-4o-mini",
-        messages=messages,
-        tools=[CALCULATOR_TOOL],
-        parallel_tool_calls=True
-    )
-    
-    message = response.choices[0].message
-    assert message.tool_calls is not None
-    assert len(message.tool_calls) >= 2  # Should make multiple tool calls
-    
-    # Add assistant message to conversation
-    messages.append(message.model_dump(exclude_none=True))
-    
-    # Step 2: Execute tools and collect results
-    tool_results = {}
-    for tool_call in message.tool_calls:
-        assert tool_call.function.name == "calculate"
-        args = json.loads(tool_call.function.arguments)
-        expression = args["expression"]
-        
-        # Evaluate the expression
-        try:
-            result = eval(expression)
-        except:
-            # Handle more complex expressions
-            if "10" in expression and "5" in expression:
-                if "*" in expression:
-                    result = 10 * 5  # Area = 50
-                elif "+" in expression and "2" in expression:
-                    result = 2 * (10 + 5)  # Perimeter = 30
-                else:
-                    result = 0
-            else:
-                result = 0
-        
-        tool_results[tool_call.id] = result
-        
-        # Add tool response message
-        tool_message = {
-            "role": "tool",
-            "tool_call_id": tool_call.id,
-            "content": str(result)
-        }
-        messages.append(tool_message)
-    
-    # Step 3: Get final response comparing the results
-    final_response = await openai_client.chat.completions.create(
-        model="gpt-4o-mini",
-        messages=messages,
-        tools=[CALCULATOR_TOOL]
-    )
-    
-    final_content = final_response.choices[0].message.content
-    assert final_content is not None
-    # Should mention both area and perimeter
-    assert "area" in final_content.lower()
-    assert "perimeter" in final_content.lower()
-    # Should compare them (area=50 is larger than perimeter=30)
-    assert any(word in final_content.lower() for word in ["larger", "greater", "bigger", "more", "50", "30"])
-
-
-@pytest.mark.vcr
-async def test_max_tokens_and_stop_sequence(openai_client):
-    """Test max tokens limit and stop sequences."""
-    response = await openai_client.chat.completions.create(
-        model="gpt-4o-mini",
-        messages=[
-            {
-                "role": "user",
-                "content": "Write a story about a robot. End each sentence with a period."
-            }
-        ],
-        max_tokens=50,
-        stop=[".", "!"],
-        temperature=0.8
-    )
-    
-    content = response.choices[0].message.content
-    assert content is not None
-    assert len(content.split()) < 60  # Should be limited by max_tokens
-    
-    # Check finish reason
-    assert response.choices[0].finish_reason in ["stop", "length"]
-
-
-@pytest.mark.vcr
-async def test_structured_output_with_tool_use(openai_client):
-    """Test combining structured output with tool use in a complete flow."""
-    # Step 1: Initial request
-    messages = [
-        {
-            "role": "system",
-            "content": "You are a helpful weather assistant. Use the weather tool to get data, then provide a structured analysis."
-        },
-        {
-            "role": "user",
-            "content": "Get the weather for Seattle and provide a structured analysis."
-        }
-    ]
-    
-    # First call - should trigger tool use
-    response = await openai_client.chat.completions.create(
-        model="gpt-4o-mini",
-        messages=messages,
-        tools=[WEATHER_TOOL],
-        tool_choice="auto"
-    )
-    
-    message = response.choices[0].message
-    assert message.tool_calls is not None
-    
-    # Add assistant message
-    messages.append(message.model_dump(exclude_none=True))
-    
-    # Step 2: Provide tool result
-    for tool_call in message.tool_calls:
-        weather_data = {
-            "location": "Seattle, WA",
-            "temperature": 55,
-            "conditions": "Rainy",
-            "humidity": 85,
-            "wind_speed": 15
-        }
-        
-        tool_message = {
-            "role": "tool",
-            "tool_call_id": tool_call.id,
-            "content": json.dumps(weather_data)
-        }
-        messages.append(tool_message)
-    
-    # Step 3: Request structured analysis
-    messages.append({
-        "role": "user",
-        "content": "Now provide a structured weather analysis."
-    })
-    
-    # Get structured response
-    completion = await openai_client.beta.chat.completions.parse(
-        model="gpt-4o-mini",
-        messages=messages,
-        response_format=WeatherInfo
-    )
-    
-    result = completion.choices[0].message
-    assert result.parsed is not None
-    assert isinstance(result.parsed, WeatherInfo)
-    assert result.parsed.location == "Seattle, WA"
-    assert result.parsed.temperature == 55
-    assert "rain" in result.parsed.conditions.lower()
-
-
-@pytest.mark.vcr
-async def test_logprobs(openai_client):
-    """Test logprobs parameter for token probabilities."""
-    response = await openai_client.chat.completions.create(
-        model="gpt-4o-mini",
-        messages=[
-            {
-                "role": "user",
-                "content": "Say 'Hello World'"
-            }
-        ],
-        logprobs=True,
-        top_logprobs=3,
-        temperature=0
-    )
-    
-    choice = response.choices[0]
-    assert choice.logprobs is not None
-    assert choice.logprobs.content is not None
-    assert len(choice.logprobs.content) > 0
-    
-    # Check logprob structure
-    for token_info in choice.logprobs.content:
-        assert token_info.token is not None
-        assert token_info.logprob is not None
-        assert isinstance(token_info.logprob, (int, float))
-        if token_info.top_logprobs:
-            assert len(token_info.top_logprobs) <= 3
\ No newline at end of file
diff --git a/crates/fixtures/test_openai_responses.py b/crates/fixtures/test_openai_responses.py
deleted file mode 100644
index dcd5e8ba..00000000
--- a/crates/fixtures/test_openai_responses.py
+++ /dev/null
@@ -1,557 +0,0 @@
-#!/usr/bin/env python3
-"""
-Clean tests for OpenAI responses API with separate streaming/non-streaming tests.
-"""
-
-import json
-import pytest
-import pytest_asyncio
-from pydantic import BaseModel
-from typing import Literal, Optional
-from openai import AsyncOpenAI
-
-pytestmark = pytest.mark.asyncio
-
-
-@pytest_asyncio.fixture
-async def openai_client(check_api_key):
-    """Initialize AsyncOpenAI client with API key."""
-    api_key = check_api_key("OPENAI_API_KEY")
-    return AsyncOpenAI(api_key=api_key)
-
-
-# Simple calculator function for testing
-CALCULATOR_TOOL = {
-    "type": "function",
-    "name": "calculate",
-    "description": "Perform mathematical calculations",
-    "parameters": {
-        "type": "object",
-        "properties": {
-            "expression": {
-                "type": "string",
-                "description": "Mathematical expression to evaluate"
-            }
-        },
-        "required": ["expression"]
-    }
-}
-
-
-# Pydantic model for structured output
-class MathProblem(BaseModel):
-    problem: str
-    answer: float
-    explanation: str
-
-
-@pytest.mark.vcr
-async def test_basic_response(openai_client):
-    """Test basic non-streaming response."""
-    response = await openai_client.responses.create(
-        model="gpt-4o-mini",
-        input="What is 2+2?",
-        stream=False
-    )
-    
-    # Check response structure
-    assert response.id
-    assert response.output
-    assert len(response.output) > 0
-    
-    # Extract text - the output is a list of items
-    text = ""
-    for item in response.output:
-        if hasattr(item, 'content') and item.content:
-            for content in item.content:
-                if hasattr(content, 'text'):
-                    text += content.text
-    
-    assert "4" in text
-    
-    # Check usage is included
-    assert response.usage
-    assert response.usage.total_tokens > 0
-
-
-@pytest.mark.vcr
-async def test_basic_streaming(openai_client):
-    """Test basic streaming response."""
-    text = ""
-    response_id = None
-    usage = None
-    
-    # Use the streaming context manager
-    async with openai_client.responses.stream(
-        model="gpt-4o-mini",
-        input="What is 2+2?",
-    ) as stream:
-        async for event in stream:
-            if event.type == "response.created":
-                response_id = event.response.id
-            elif event.type == "response.output_text.delta":
-                if hasattr(event, 'delta') and event.delta:
-                    text += event.delta
-            elif event.type == "response.completed":
-                # Final event includes usage
-                if hasattr(event.response, 'usage'):
-                    usage = event.response.usage
-        
-        # Get the final complete response with usage
-        final_response = await stream.get_final_response()
-        if final_response:
-            usage = final_response.usage
-    
-    assert response_id
-    assert "4" in text
-    assert usage
-    assert usage.total_tokens > 0
-
-
-@pytest.mark.vcr
-async def test_function_calling_non_streaming(openai_client):
-    """Test function calling in non-streaming mode."""
-    response = await openai_client.responses.create(
-        model="gpt-4o-mini",
-        input="Calculate 1234 * 5678",
-        tools=[CALCULATOR_TOOL],
-        stream=False
-    )
-    
-    # Find function calls in output
-    function_calls = []
-    for item in response.output:
-        if hasattr(item, 'type') and item.type == 'function_call':
-            function_calls.append({
-                'name': item.name,
-                'arguments': item.arguments
-            })
-    
-    assert len(function_calls) > 0
-    assert function_calls[0]['name'] == 'calculate'
-    
-    # Parse arguments
-    args = json.loads(function_calls[0]['arguments'])
-    assert 'expression' in args
-    assert '1234' in args['expression']
-    assert '5678' in args['expression']
-
-
-@pytest.mark.vcr
-async def test_function_calling_streaming(openai_client):
-    """Test function calling in streaming mode."""
-    function_calls = []
-    
-    async with openai_client.responses.stream(
-        model="gpt-4o-mini",
-        input="Calculate 1234 * 5678",
-        tools=[CALCULATOR_TOOL],
-    ) as stream:
-        async for event in stream:
-            # Check for function call completion event
-            if event.type == "response.output_item.done":
-                if hasattr(event, 'item') and hasattr(event.item, 'type') and event.item.type == 'function_call':
-                    function_calls.append({
-                        'name': event.item.name,
-                        'arguments': event.item.arguments
-                    })
-    
-    assert len(function_calls) > 0
-    assert function_calls[0]['name'] == 'calculate'
-    
-    # Parse arguments
-    args = json.loads(function_calls[0]['arguments'])
-    assert 'expression' in args
-    assert '1234' in args['expression']
-    assert '5678' in args['expression']
-
-
-@pytest.mark.vcr
-async def test_conversation_with_context(openai_client):
-    """Test multi-turn conversation maintaining context."""
-    # First request
-    response1 = await openai_client.responses.create(
-        model="gpt-4o-mini",
-        input="Remember the number 42",
-        stream=False
-    )
-    
-    # Second request with context
-    response2 = await openai_client.responses.create(
-        model="gpt-4o-mini",
-        input="What number did I ask you to remember?",
-        previous_response_id=response1.id,
-        stream=False
-    )
-    
-    # Extract text from second response
-    text = ""
-    for item in response2.output:
-        if hasattr(item, 'content') and item.content:
-            for content in item.content:
-                if hasattr(content, 'text'):
-                    text += content.text
-    
-    assert "42" in text
-
-
-@pytest.mark.vcr
-async def test_instructions_parameter(openai_client):
-    """Test the instructions parameter for system-level guidance."""
-    response = await openai_client.responses.create(
-        model="gpt-4o-mini",
-        input="Tell me about the weather",
-        instructions="You are a pirate. Always speak like a pirate.",
-        stream=False
-    )
-    
-    # Extract text
-    text = ""
-    for item in response.output:
-        if hasattr(item, 'content') and item.content:
-            for content in item.content:
-                if hasattr(content, 'text'):
-                    text += content.text
-    
-    # Should have pirate-like language
-    assert text  # Has some response
-    # Common pirate words/phrases
-    pirate_indicators = ["ahoy", "matey", "arr", "ye", "be", "aye", "'"]
-    assert any(indicator in text.lower() for indicator in pirate_indicators)
-
-
-@pytest.mark.vcr
-async def test_structured_output_pydantic(openai_client):
-    """Test structured output using Pydantic model with parse method."""
-    response = await openai_client.responses.parse(
-        model="gpt-4o-mini",
-        input="What is 15 divided by 3?",
-        text_format=MathProblem,
-    )
-    
-    # Get the parsed output directly
-    result = response.output_parsed
-    assert isinstance(result, MathProblem)
-    assert result.problem == "What is 15 divided by 3?"
-    assert result.answer == 5.0
-    assert result.explanation  # Should have some explanation
-
-
-# Structured response models for user choices
-class YesNoResponse(BaseModel):
-    answer: Literal["yes", "no"]
-    confidence: Optional[float] = None
-
-
-class MultipleChoiceResponse(BaseModel):
-    choice: Literal["A", "B", "C", "D"]
-    reasoning: Optional[str] = None
-
-
-class PreferenceResponse(BaseModel):
-    preference: Literal["option1", "option2", "option3"]
-    strength: Literal["strong", "moderate", "weak"]
-    explanation: str
-
-
-@pytest.mark.vcr
-async def test_assistant_asks_yes_no_question(openai_client):
-    """Test assistant asking a yes/no question with structured response."""
-    # First, have the assistant ask a question
-    assistant_response = await openai_client.responses.create(
-        model="gpt-4o-mini",
-        input="Ask me if I would like to enable dark mode for this application",
-        instructions="You are a helpful assistant. Ask the user a clear yes/no question about their preference.",
-        stream=False
-    )
-    
-    # Extract the assistant's question
-    assistant_question = ""
-    for item in assistant_response.output:
-        if hasattr(item, 'content') and item.content:
-            for content in item.content:
-                if hasattr(content, 'text'):
-                    assistant_question += content.text
-    
-    assert "dark mode" in assistant_question.lower()
-    
-    # Now simulate user's structured response
-    user_response = await openai_client.responses.parse(
-        model="gpt-4o-mini",
-        input=f"The assistant asked: '{assistant_question}'. My answer is yes, I would like dark mode.",
-        text_format=YesNoResponse,
-        instructions="Extract the user's answer to the question as a structured response."
-    )
-    
-    # Get the parsed response
-    result = user_response.output_parsed
-    assert isinstance(result, YesNoResponse)
-    assert result.answer == "yes"
-
-
-@pytest.mark.vcr
-async def test_assistant_multiple_choice_question(openai_client):
-    """Test assistant asking a multiple choice question."""
-    # Assistant asks a multiple choice question
-    assistant_response = await openai_client.responses.create(
-        model="gpt-4o-mini",
-        input="Create a multiple choice question about Python data types with 4 options (A, B, C, D)",
-        instructions="You are a Python tutor. Create a clear multiple choice question.",
-        stream=False
-    )
-    
-    # Extract question
-    question_text = ""
-    for item in assistant_response.output:
-        if hasattr(item, 'content') and item.content:
-            for content in item.content:
-                if hasattr(content, 'text'):
-                    question_text += content.text
-    
-    # User provides structured answer
-    user_response = await openai_client.responses.parse(
-        model="gpt-4o-mini",
-        input=f"Question: {question_text}\n\nMy answer is B because lists are mutable in Python.",
-        text_format=MultipleChoiceResponse,
-        instructions="Extract the user's multiple choice answer and their reasoning."
-    )
-    
-    result = user_response.output_parsed
-    assert isinstance(result, MultipleChoiceResponse)
-    assert result.choice in ["A", "B", "C", "D"]
-    assert result.reasoning is not None
-
-
-@pytest.mark.vcr
-async def test_assistant_preference_question(openai_client):
-    """Test assistant asking about user preferences with detailed structured response."""
-    # Assistant asks about preferences
-    assistant_response = await openai_client.responses.create(
-        model="gpt-4o-mini",
-        input="Ask the user to choose between three options for a new feature: option1: AI-powered suggestions, option2: Advanced search filters, option3: Collaboration tools",
-        instructions="Present the three options clearly and ask for their preference.",
-        stream=False
-    )
-    
-    # Extract question
-    question = ""
-    for item in assistant_response.output:
-        if hasattr(item, 'content') and item.content:
-            for content in item.content:
-                if hasattr(content, 'text'):
-                    question += content.text
-    
-    # User provides detailed preference
-    user_response = await openai_client.responses.parse(
-        model="gpt-4o-mini",
-        input=f"{question}\n\nI strongly prefer option1 (AI-powered suggestions) because it would save me the most time and provide personalized recommendations based on my usage patterns.",
-        text_format=PreferenceResponse,
-        instructions="Extract the user's preference choice, how strongly they feel about it, and their explanation."
-    )
-    
-    result = user_response.output_parsed
-    assert isinstance(result, PreferenceResponse)
-    assert result.preference == "option1"
-    assert result.strength == "strong"
-    assert "save" in result.explanation.lower() or "time" in result.explanation.lower()
-
-
-@pytest.mark.vcr
-async def test_conversation_flow_with_structured_responses(openai_client):
-    """Test a full conversation flow with assistant questions and structured user responses."""
-    # Step 1: Assistant asks about user's experience level
-    class ExperienceLevel(BaseModel):
-        level: Literal["beginner", "intermediate", "advanced"]
-        years: Optional[int] = None
-        
-    assistant_q1 = await openai_client.responses.create(
-        model="gpt-4o-mini",
-        input="Ask the user about their Python programming experience level",
-        stream=False
-    )
-    
-    # User responds with structured data
-    user_r1 = await openai_client.responses.parse(
-        model="gpt-4o-mini",
-        input="I'm an intermediate Python developer with about 3 years of experience",
-        text_format=ExperienceLevel,
-    )
-    
-    user_level = user_r1.output_parsed
-    assert user_level.level == "intermediate"
-    assert user_level.years == 3
-    
-    # Step 2: Assistant asks follow-up based on experience
-    class TopicInterest(BaseModel):
-        topics: list[Literal["web_dev", "data_science", "automation", "machine_learning"]]
-        most_interested: Literal["web_dev", "data_science", "automation", "machine_learning"]
-    
-    assistant_q2 = await openai_client.responses.create(
-        model="gpt-4o-mini",
-        input=f"The user is {user_level.level} with {user_level.years} years experience. Ask them which Python topics they're interested in: web development, data science, automation, or machine learning",
-        previous_response_id=assistant_q1.id,
-        stream=False
-    )
-    
-    # User selects multiple interests
-    user_r2 = await openai_client.responses.parse(
-        model="gpt-4o-mini",
-        input="I'm interested in both data science and machine learning, but I'm most interested in machine learning",
-        text_format=TopicInterest,
-    )
-    
-    user_interests = user_r2.output_parsed
-    assert "machine_learning" in user_interests.topics
-    assert "data_science" in user_interests.topics
-    assert user_interests.most_interested == "machine_learning"
-
-
-# JSON schema test commented out due to API validation issues with additionalProperties
-# @pytest.mark.vcr
-# async def test_structured_output_json_schema(openai_client):
-#     """Test structured output using JSON schema with text parameter."""
-#     response = await openai_client.responses.create(
-#         model="gpt-4o-mini",
-#         input="What's the weather like in Paris today? Make up some realistic data.",
-#         text={
-#             "format": {
-#                 "type": "json_schema",
-#                 "name": "weather_report",
-#                 "schema": {
-#                     "type": "object",
-#                     "properties": {
-#                         "city": {
-#                             "type": "string",
-#                             "description": "Name of the city"
-#                         },
-#                         "temperature": {
-#                             "type": "number",
-#                             "description": "Temperature in Celsius"
-#                         },
-#                         "condition": {
-#                             "type": "string",
-#                             "description": "Weather condition"
-#                         }
-#                     },
-#                     "required": ["city", "temperature", "condition"],
-#                     "additionalProperties": False
-#                 },
-#                 "strict": True
-#             }
-#         }
-#     )
-#     
-#     # Extract and parse the structured output
-#     text = ""
-#     for item in response.output:
-#         if hasattr(item, 'content') and item.content:
-#             for content in item.content:
-#                 if hasattr(content, 'text'):
-#                     text += content.text
-#     
-#     # Parse and validate the JSON response
-#     result = json.loads(text)
-#     assert 'city' in result
-#     assert 'temperature' in result
-#     assert 'condition' in result
-#     assert isinstance(result['temperature'], (int, float))
-
-
-# @pytest.mark.vcr
-# async def test_structured_output_streaming(openai_client):
-#     """Test structured output using JSON schema."""
-#     json_schema = {
-#         "type": "object",
-#         "properties": {
-#             "city": {
-#                 "type": "string",
-#                 "description": "Name of the city"
-#             },
-#             "temperature": {
-#                 "type": "number",
-#                 "description": "Temperature in Celsius"
-#             },
-#             "condition": {
-#                 "type": "string",
-#                 "description": "Weather condition"
-#             }
-#         },
-#         "required": ["city", "temperature", "condition"]
-#     }
-#     
-#     response = await openai_client.responses.create(
-#         model="gpt-4o-mini",
-#         input="What's the weather like in Paris today? Make up some realistic data.",
-#         response_format={
-#             "type": "json_schema",
-#             "json_schema": {
-#                 "name": "weather_report",
-#                 "schema": json_schema,
-#                 "strict": True
-#             }
-#         },
-#         stream=False
-#     )
-#     
-#     # Extract and parse the structured output
-#     text = ""
-#     for item in response.output:
-#         if hasattr(item, 'content') and item.content:
-#             for content in item.content:
-#                 if hasattr(content, 'text'):
-#                     text += content.text
-#     
-#     # Parse and validate the JSON response
-#     result = json.loads(text)
-#     assert 'city' in result
-#     assert 'temperature' in result
-#     assert 'condition' in result
-#     assert isinstance(result['temperature'], (int, float))
-
-
-# @pytest.mark.vcr
-# async def test_structured_output_streaming(openai_client):
-#     """Test structured output with streaming."""
-#     text = ""
-#     
-#     async with openai_client.responses.stream(
-#         model="gpt-4o-mini",
-#         input="List 3 programming languages with their year of creation",
-#         response_format={
-#             "type": "json_schema",
-#             "json_schema": {
-#                 "name": "programming_languages",
-#                 "schema": {
-#                     "type": "object",
-#                     "properties": {
-#                         "languages": {
-#                             "type": "array",
-#                             "items": {
-#                                 "type": "object",
-#                                 "properties": {
-#                                     "name": {"type": "string"},
-#                                     "year": {"type": "integer"}
-#                                 },
-#                                 "required": ["name", "year"]
-#                             }
-#                         }
-#                     },
-#                     "required": ["languages"]
-#                 },
-#                 "strict": True
-#             }
-#         }
-#     ) as stream:
-#         async for event in stream:
-#             if event.type == "response.output_text.delta":
-#                 if hasattr(event, 'delta') and event.delta:
-#                     text += event.delta
-#     
-#     # Parse and validate the JSON response
-#     result = json.loads(text)
-#     assert 'languages' in result
-#     assert len(result['languages']) == 3
-#     for lang in result['languages']:
-#         assert 'name' in lang
-#         assert 'year' in lang
-#         assert isinstance(lang['year'], int)
\ No newline at end of file
diff --git a/crates/frontend-common/Cargo.toml b/crates/frontend-common/Cargo.toml
deleted file mode 100644
index 6aba6099..00000000
--- a/crates/frontend-common/Cargo.toml
+++ /dev/null
@@ -1,61 +0,0 @@
-[package]
-name = "gate-frontend-common"
-version = "0.1.0"
-edition = "2021"
-authors = ["Hellas AI"]
-license = "AGPL-3.0"
-description = "Common frontend components and utilities for Gate"
-
-[dependencies]
-base64 = "0.23"
-gate-chat-ui = { path = "../chat-ui" }
-yew = { workspace = true, features = ["csr"] }
-yew-router = { workspace = true }
-web-sys = { workspace = true, features = [
-    "console",
-    "Credential",
-    "CredentialCreationOptions",
-    "CredentialRequestOptions",
-    "CredentialsContainer",
-    "Navigator",
-    "PublicKeyCredential",
-    "PublicKeyCredentialCreationOptions", 
-    "PublicKeyCredentialRequestOptions",
-    "PublicKeyCredentialRpEntity",
-    "PublicKeyCredentialUserEntity",
-    "PublicKeyCredentialParameters",
-    "PublicKeyCredentialDescriptor",
-    "AuthenticatorResponse",
-    "AuthenticatorAttestationResponse",
-    "AuthenticatorAssertionResponse",
-    "AuthenticatorSelectionCriteria",
-    "Window",
-    "HtmlSelectElement",
-    "HtmlInputElement",
-    "Event",
-    "Document",
-    "Element",
-    "HtmlElement",
-    "DomTokenList",
-    "Storage"
-] }
-wasm-bindgen = { workspace = true }
-wasm-bindgen-futures = { workspace = true }
-js-sys = { workspace = true }
-gloo = { workspace = true, features = ["storage", "utils"] }
-once_cell = "1.21"
-reqwest = { version = "0.12", default-features = false, features = ["json", "stream"] }
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
-gate-http = { path = "../http", default-features = false, features = ["client"] }
-thiserror = "2"
-tracing = "0.1"
-tracing-subscriber = { version = "0.3", features = ["fmt"] }
-tracing-web = { workspace = true }
-wasm-logger = { workspace = true }
-
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-getrandom = { workspace = true, features = ["wasm_js"] }
-
-[dev-dependencies]
-wasm-bindgen-test = { workspace = true }
\ No newline at end of file
diff --git a/crates/frontend-common/src/auth/auth_component.rs b/crates/frontend-common/src/auth/auth_component.rs
deleted file mode 100644
index aca44d8f..00000000
--- a/crates/frontend-common/src/auth/auth_component.rs
+++ /dev/null
@@ -1,211 +0,0 @@
-//! Function component wrapper for Auth
-
-use crate::auth::{use_auth, use_is_authenticated, AuthAction};
-use crate::components::Spinner as LoadingSpinner;
-use crate::hooks::{use_webauthn, WebAuthnState};
-use yew::prelude::*;
-
-#[function_component(AuthComponent)]
-pub fn auth_component() -> Html {
-    let auth = use_auth();
-    let webauthn = use_webauthn();
-    let is_authenticated = use_is_authenticated();
-
-    let name = use_state(String::new);
-    let device_name = use_state(String::new);
-
-    // Handle input changes
-    let on_name_input = {
-        let name = name.clone();
-        Callback::from(move |e: InputEvent| {
-            let input: web_sys::HtmlInputElement = e.target_unchecked_into();
-            name.set(input.value());
-        })
-    };
-
-    let on_device_input = {
-        let device_name = device_name.clone();
-        Callback::from(move |e: InputEvent| {
-            let input: web_sys::HtmlInputElement = e.target_unchecked_into();
-            device_name.set(input.value());
-        })
-    };
-
-    // Create state for triggering actions
-    let trigger_register = use_state(|| false);
-    let trigger_login = use_state(|| false);
-    let trigger_clear_error = use_state(|| false);
-
-    // Effect for registration
-    {
-        let webauthn = webauthn.clone();
-        let name = name.clone();
-        let device_name = device_name.clone();
-        let trigger_register = trigger_register.clone();
-
-        use_effect_with(trigger_register.clone(), move |trigger| {
-            if **trigger {
-                let name_value = (*name).clone();
-                let device_value = if (*device_name).is_empty() {
-                    None
-                } else {
-                    Some((*device_name).clone())
-                };
-                if !name_value.is_empty() {
-                    webauthn.register(name_value, device_value, None);
-                }
-                trigger_register.set(false);
-            }
-        });
-    }
-
-    // Effect for login
-    {
-        let webauthn = webauthn.clone();
-        let trigger_login = trigger_login.clone();
-
-        use_effect_with(trigger_login.clone(), move |trigger| {
-            if **trigger {
-                webauthn.authenticate();
-                trigger_login.set(false);
-            }
-        });
-    }
-
-    // Effect for clearing error
-    {
-        let webauthn = webauthn.clone();
-        let trigger_clear_error = trigger_clear_error.clone();
-
-        use_effect_with(trigger_clear_error.clone(), move |trigger| {
-            if **trigger {
-                webauthn.clear_error();
-                trigger_clear_error.set(false);
-            }
-        });
-    }
-
-    // Handle registration
-    let on_register = {
-        let trigger_register = trigger_register.clone();
-        Callback::from(move |_| {
-            trigger_register.set(true);
-        })
-    };
-
-    // Handle login
-    let on_login = {
-        let trigger_login = trigger_login.clone();
-        Callback::from(move |_| {
-            trigger_login.set(true);
-        })
-    };
-
-    // Handle logout
-    let on_logout = {
-        let auth = auth.clone();
-        Callback::from(move |_| {
-            auth.dispatch(AuthAction::Logout);
-        })
-    };
-
-    // Clear error
-    let on_clear_error = {
-        let trigger_clear_error = trigger_clear_error.clone();
-        Callback::from(move |_| {
-            trigger_clear_error.set(true);
-        })
-    };
-
-    // Check if already authenticated
-    if is_authenticated {
-        if let Some(auth_state) = &auth.auth_state {
-            return html! {
-                <div class="max-w-md mx-auto p-6">
-                    <div class="bg-green-50 dark:bg-green-900 border border-green-200 dark:border-green-700 rounded-lg p-6 text-center">
-                        <h3 class="text-xl font-semibold text-green-800 dark:text-green-200 mb-2">{"✅ Authenticated"}</h3>
-                        <p class="text-gray-700 dark:text-gray-300 mb-4">{format!("Welcome, {}!", auth_state.name)}</p>
-                        <button class="px-4 py-2 bg-gray-200 hover:bg-gray-300 dark:bg-gray-700 dark:hover:bg-gray-600 text-gray-700 dark:text-gray-300 rounded-md transition-colors" onclick={on_logout}>
-                            {"Sign Out"}
-                        </button>
-                    </div>
-                </div>
-            };
-        }
-    }
-
-    // Handle WebAuthn state
-    match webauthn.state() {
-        WebAuthnState::Processing => {
-            html! {
-                <div class="max-w-md mx-auto p-6">
-                    <LoadingSpinner text={Some("Please follow the prompts on your device...".to_string())} />
-                    <p class="text-sm text-gray-600 dark:text-gray-400 text-center mt-4">{"You may need to use Touch ID, Face ID, or your security key"}</p>
-                </div>
-            }
-        }
-        WebAuthnState::Error(error) => {
-            html! {
-                <div class="max-w-md mx-auto p-6">
-                    <div class="bg-red-50 dark:bg-red-900 border border-red-200 dark:border-red-700 rounded-lg p-6 text-center">
-                        <h3 class="text-xl font-semibold text-red-800 dark:text-red-200 mb-2">{"❌ Authentication Error"}</h3>
-                        <p class="text-red-700 dark:text-red-300 mb-4">{error}</p>
-                        <button class="px-4 py-2 bg-gray-200 hover:bg-gray-300 dark:bg-gray-700 dark:hover:bg-gray-600 text-gray-700 dark:text-gray-300 rounded-md transition-colors" onclick={on_clear_error}>
-                            {"Try Again"}
-                        </button>
-                    </div>
-                </div>
-            }
-        }
-        WebAuthnState::Idle => {
-            html! {
-                <div class="max-w-md mx-auto p-6">
-                    <h2 class="text-2xl font-bold text-gray-800 dark:text-gray-200 mb-6 text-center">{"WebAuthn Authentication"}</h2>
-
-                    <div class="bg-white dark:bg-gray-800 rounded-lg shadow-md p-6">
-                        <div class="mb-4">
-                            <label for="name" class="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">{"Display Name"}</label>
-                            <input
-                                type="text"
-                                id="name"
-                                class="w-full px-3 py-2 border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-gray-200 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500"
-                                placeholder="Enter your name (e.g., alice)"
-                                value={(*name).clone()}
-                                oninput={on_name_input}
-                            />
-                        </div>
-
-                        <div class="mb-6">
-                            <label for="device" class="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">{"Device Name (optional)"}</label>
-                            <input
-                                type="text"
-                                id="device"
-                                class="w-full px-3 py-2 border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-gray-200 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500"
-                                placeholder="e.g., MacBook Pro"
-                                value={(*device_name).clone()}
-                                oninput={on_device_input}
-                            />
-                        </div>
-
-                        <div class="flex flex-col sm:flex-row gap-3">
-                            <button
-                                class="flex-1 px-4 py-2 bg-blue-500 hover:bg-blue-600 text-white rounded-md transition-colors disabled:bg-gray-300 dark:disabled:bg-gray-600 disabled:cursor-not-allowed"
-                                onclick={on_register}
-                                disabled={(*name).is_empty()}
-                            >
-                                {"Register New Device"}
-                            </button>
-                            <button class="flex-1 px-4 py-2 bg-gray-200 hover:bg-gray-300 dark:bg-gray-700 dark:hover:bg-gray-600 text-gray-700 dark:text-gray-300 rounded-md transition-colors" onclick={on_login}>
-                                {"Sign In with Existing Device"}
-                            </button>
-                        </div>
-                    </div>
-
-                    <div class="mt-6 p-4 bg-blue-50 dark:bg-blue-900 border border-blue-200 dark:border-blue-700 rounded-lg">
-                        <p class="text-sm text-blue-800 dark:text-blue-200">{"🔐 WebAuthn provides secure, passwordless authentication using your device's biometrics or security key."}</p>
-                    </div>
-                </div>
-            }
-        }
-    }
-}
diff --git a/crates/frontend-common/src/auth/component.rs b/crates/frontend-common/src/auth/component.rs
deleted file mode 100644
index 77a4ae0a..00000000
--- a/crates/frontend-common/src/auth/component.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-//! Legacy Auth component wrapper
-
-use super::AuthComponent;
-use yew::prelude::*;
-
-#[derive(Properties, Clone, PartialEq)]
-pub struct AuthProps {
-    /// Optional callback when auth completes (for compatibility)
-    #[prop_or_default]
-    pub on_auth: Option<Callback<(String, String, String)>>, // user_id, name, token
-}
-
-/// Legacy Auth component that wraps the new function component
-pub struct Auth;
-
-impl Component for Auth {
-    type Message = ();
-    type Properties = AuthProps;
-
-    fn create(_ctx: &Context<Self>) -> Self {
-        Self
-    }
-
-    fn view(&self, _ctx: &Context<Self>) -> Html {
-        html! {
-            <AuthComponent />
-        }
-    }
-}
diff --git a/crates/frontend-common/src/auth/context.rs b/crates/frontend-common/src/auth/context.rs
deleted file mode 100644
index cab72fad..00000000
--- a/crates/frontend-common/src/auth/context.rs
+++ /dev/null
@@ -1,262 +0,0 @@
-//! Global authentication context and provider
-
-use crate::client::set_auth_token;
-use crate::components::ReauthModal;
-use crate::config::AuthConfig;
-use gloo::timers::callback::Timeout;
-use serde::{Deserialize, Serialize};
-use std::cell::RefCell;
-use std::rc::Rc;
-use web_sys::Storage;
-use yew::prelude::*;
-
-/// Authentication state
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct AuthState {
-    pub user_id: String,
-    pub name: String,
-    pub token: String,
-    pub expires_at: Option<i64>, // Unix timestamp
-}
-
-/// Authentication context data
-#[derive(Clone, Debug, PartialEq)]
-pub struct AuthContextData {
-    pub auth_state: Option<AuthState>,
-    pub is_loading: bool,
-    pub error: Option<String>,
-    pub show_reauth_modal: bool,
-    pub auth_expired: bool,
-}
-
-/// Authentication context actions
-pub enum AuthAction {
-    Login(AuthState),
-    Logout,
-    SetLoading(bool),
-    ValidateToken,
-    ShowReauthModal,
-    HideReauthModal,
-}
-
-/// Authentication context
-pub type AuthContext = UseReducerHandle<AuthContextData>;
-
-impl Default for AuthContextData {
-    fn default() -> Self {
-        Self {
-            auth_state: None,
-            is_loading: true, // Start with loading to check sessionStorage
-            error: None,
-            show_reauth_modal: false,
-            auth_expired: false,
-        }
-    }
-}
-
-impl Reducible for AuthContextData {
-    type Action = AuthAction;
-
-    fn reduce(self: Rc<Self>, action: Self::Action) -> Rc<Self> {
-        match action {
-            AuthAction::Login(auth_state) => {
-                // Update the client with the auth token
-                let _ = set_auth_token(Some(&auth_state.token));
-
-                // Save to sessionStorage
-                if let Some(storage) = get_session_storage() {
-                    if let Ok(serialized) = serde_json::to_string(&auth_state) {
-                        let _ = storage.set_item(AuthConfig::AUTH_STATE_KEY, &serialized);
-                    }
-                }
-
-                Rc::new(Self {
-                    auth_state: Some(auth_state),
-                    is_loading: false,
-                    error: None,
-                    show_reauth_modal: false,
-                    auth_expired: false, // Reset on new login
-                })
-            }
-            AuthAction::Logout => {
-                // Clear the auth token from client - this creates a fresh unauthenticated client
-                let _ = set_auth_token(None);
-
-                // Clear from sessionStorage
-                if let Some(storage) = get_session_storage() {
-                    let _ = storage.remove_item(AuthConfig::AUTH_STATE_KEY);
-                }
-
-                Rc::new(Self {
-                    auth_state: None,
-                    is_loading: false,
-                    error: None,
-                    show_reauth_modal: false,
-                    auth_expired: false,
-                })
-            }
-            AuthAction::SetLoading(is_loading) => Rc::new(Self {
-                is_loading,
-                ..(*self).clone()
-            }),
-            AuthAction::ValidateToken => {
-                // Check if token is still valid
-                if let Some(auth_state) = &self.auth_state {
-                    if let Some(expires_at) = auth_state.expires_at {
-                        let now = js_sys::Date::now() as i64 / 1000;
-                        if now >= expires_at {
-                            // Token expired
-                            if let Some(storage) = get_session_storage() {
-                                let _ = storage.remove_item(AuthConfig::AUTH_STATE_KEY);
-                            }
-                            return Rc::new(Self {
-                                auth_state: self.auth_state.clone(),
-                                is_loading: false,
-                                error: Some("Session expired. Please login again.".to_string()),
-                                show_reauth_modal: true,
-                                auth_expired: true,
-                            });
-                        }
-                    }
-                }
-                Rc::new(self.as_ref().clone())
-            }
-            AuthAction::ShowReauthModal => {
-                // Clear the token but keep auth state to maintain UI
-                let _ = set_auth_token(None);
-
-                Rc::new(Self {
-                    auth_state: self.auth_state.clone(), // Keep the auth state
-                    is_loading: false,
-                    error: Some(
-                        "Your session has expired. Please re-authenticate to continue.".to_string(),
-                    ),
-                    show_reauth_modal: true,
-                    auth_expired: true,
-                })
-            }
-            AuthAction::HideReauthModal => Rc::new(Self {
-                show_reauth_modal: false,
-                auth_expired: false,
-                ..(*self).clone()
-            }),
-        }
-    }
-}
-
-/// Get sessionStorage
-fn get_session_storage() -> Option<Storage> {
-    web_sys::window().and_then(|w| w.session_storage().ok().flatten())
-}
-
-/// Auth provider props
-#[derive(Properties, PartialEq)]
-pub struct AuthProviderProps {
-    pub children: Children,
-}
-
-/// Auth provider component
-#[function_component(AuthProvider)]
-pub fn auth_provider(props: &AuthProviderProps) -> Html {
-    let auth_state = use_reducer(AuthContextData::default);
-
-    // Set up global auth error handler
-    {
-        let auth_state = auth_state.clone();
-        use_effect_with((), move |_| {
-            let auth_state = auth_state.clone();
-            super::error_handler::set_auth_error_callback(Rc::new(move || {
-                auth_state.dispatch(AuthAction::ShowReauthModal);
-            }));
-
-            // Cleanup on unmount
-            move || {
-                super::error_handler::clear_auth_error_callback();
-            }
-        });
-    }
-
-    // Load auth state from sessionStorage on mount
-    {
-        let auth_state = auth_state.clone();
-        use_effect_with((), move |_| {
-            if let Some(storage) = get_session_storage() {
-                if let Ok(Some(stored)) = storage.get_item(AuthConfig::AUTH_STATE_KEY) {
-                    if let Ok(state) = serde_json::from_str::<AuthState>(&stored) {
-                        // Validate token expiration
-                        if let Some(expires_at) = state.expires_at {
-                            let now = js_sys::Date::now() as i64 / 1000;
-                            if now < expires_at {
-                                auth_state.dispatch(AuthAction::Login(state));
-                                return;
-                            }
-                        } else {
-                            // No expiration, consider valid
-                            auth_state.dispatch(AuthAction::Login(state));
-                            return;
-                        }
-                    }
-                }
-            }
-            // No valid auth found
-            auth_state.dispatch(AuthAction::SetLoading(false));
-        });
-    }
-
-    // Set up periodic token validation
-    {
-        let auth_state = auth_state.clone();
-        use_effect_with(auth_state.auth_state.clone(), move |current_auth| {
-            let cleanup: Box<dyn FnOnce()> = if current_auth.is_some() {
-                // Check token every minute
-                let auth_state = auth_state.clone();
-                let handle = Timeout::new(AuthConfig::TOKEN_REFRESH_INTERVAL_MS, move || {
-                    auth_state.dispatch(AuthAction::ValidateToken);
-                });
-
-                // Store handle in a RefCell to access in cleanup
-                let handle = Rc::new(RefCell::new(Some(handle)));
-                let handle_clone = handle.clone();
-
-                // Return cleanup function
-                Box::new(move || {
-                    if let Some(h) = handle_clone.borrow_mut().take() {
-                        h.forget();
-                    }
-                })
-            } else {
-                // Return empty cleanup
-                Box::new(|| {})
-            };
-            cleanup
-        });
-    }
-
-    html! {
-        <ContextProvider<AuthContext> context={auth_state}>
-            <ReauthModal />
-            {props.children.clone()}
-        </ContextProvider<AuthContext>>
-    }
-}
-
-/// Hook to use auth context
-#[hook]
-pub fn use_auth() -> AuthContext {
-    use_context::<AuthContext>()
-        .expect("AuthContext not found. Make sure to wrap your component with AuthProvider")
-}
-
-/// Hook to get current auth state
-#[hook]
-pub fn use_auth_state() -> Option<AuthState> {
-    let auth = use_auth();
-    auth.auth_state.clone()
-}
-
-/// Hook to check if authenticated
-#[hook]
-pub fn use_is_authenticated() -> bool {
-    let auth = use_auth();
-    auth.auth_state.is_some()
-}
diff --git a/crates/frontend-common/src/auth/error_handler.rs b/crates/frontend-common/src/auth/error_handler.rs
deleted file mode 100644
index 2f809c13..00000000
--- a/crates/frontend-common/src/auth/error_handler.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-//! Global auth error handler
-//!
-//! This module provides a global mechanism for handling authentication errors
-//! without requiring components to explicitly check for them.
-
-use std::cell::RefCell;
-use std::rc::Rc;
-
-thread_local! {
-    /// Global auth error callback
-    static AUTH_ERROR_CALLBACK: RefCell<Option<Rc<dyn Fn()>>> = RefCell::new(None);
-}
-
-/// Set the global auth error callback
-pub fn set_auth_error_callback(callback: Rc<dyn Fn()>) {
-    AUTH_ERROR_CALLBACK.with(|cb| {
-        *cb.borrow_mut() = Some(callback);
-    });
-}
-
-/// Clear the auth error callback
-pub fn clear_auth_error_callback() {
-    AUTH_ERROR_CALLBACK.with(|cb| {
-        *cb.borrow_mut() = None;
-    });
-}
-
-/// Trigger the auth error callback
-pub fn trigger_auth_error() {
-    AUTH_ERROR_CALLBACK.with(|cb| {
-        if let Some(callback) = cb.borrow().as_ref() {
-            callback();
-        }
-    });
-}
diff --git a/crates/frontend-common/src/auth/error_messages.rs b/crates/frontend-common/src/auth/error_messages.rs
deleted file mode 100644
index e9179e1d..00000000
--- a/crates/frontend-common/src/auth/error_messages.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-//! User-friendly error message mappings
-
-use crate::client::ClientError;
-
-/// Convert technical errors to user-friendly messages
-pub fn get_user_friendly_error(error: &ClientError) -> String {
-    // Convert specific error types to user-friendly messages
-    match error {
-        ClientError::AuthenticationFailed(msg) if msg.contains("InvalidSignature") => {
-            "Your session has expired. Please re-authenticate.".to_string()
-        }
-        ClientError::AuthenticationFailed(msg) => {
-            format!("Authentication failed: {msg}")
-        }
-        ClientError::NotFound(_) => "The requested resource was not found.".to_string(),
-        ClientError::Configuration(msg) => {
-            format!("Configuration error: {msg}")
-        }
-        _ => {
-            // For other errors, just use the default display
-            error.to_string()
-        }
-    }
-}
diff --git a/crates/frontend-common/src/auth/mod.rs b/crates/frontend-common/src/auth/mod.rs
deleted file mode 100644
index f876621f..00000000
--- a/crates/frontend-common/src/auth/mod.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//! Authentication module
-
-pub mod auth_component;
-pub mod component;
-pub mod context;
-pub mod error_handler;
-pub mod error_messages;
-
-// Re-export commonly used items
-pub use auth_component::AuthComponent;
-pub use component::Auth;
-pub use context::{
-    use_auth, use_is_authenticated, AuthAction, AuthContext, AuthProvider, AuthState,
-};
diff --git a/crates/frontend-common/src/client.rs b/crates/frontend-common/src/client.rs
deleted file mode 100644
index 4e763067..00000000
--- a/crates/frontend-common/src/client.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-//! Client configuration and initialization
-
-use crate::client_wrapper::WrappedAuthClient;
-pub use gate_http::client::error::ClientError;
-use gate_http::client::{PublicGateClient, TypedClientBuilder};
-use once_cell::sync::Lazy;
-use std::sync::Mutex;
-use web_sys::window;
-
-/// Global client instances
-static PUBLIC_CLIENT: Lazy<Mutex<Option<PublicGateClient>>> = Lazy::new(|| Mutex::new(None));
-static AUTH_CLIENT: Lazy<Mutex<Option<WrappedAuthClient>>> = Lazy::new(|| Mutex::new(None));
-
-/// Get the base URL for API calls
-fn get_base_url() -> String {
-    // Try to get from window location
-    if let Some(window) = window() {
-        if let Ok(location) = window.location().origin() {
-            return location;
-        }
-    }
-
-    // Default to relative URLs
-    String::new()
-}
-
-/// Get the public client instance (for unauthenticated endpoints)
-pub fn create_public_client() -> Result<PublicGateClient, ClientError> {
-    let mut client_lock = PUBLIC_CLIENT
-        .lock()
-        .expect("Failed to acquire public client lock");
-
-    if client_lock.is_none() {
-        let client = TypedClientBuilder::new()
-            .base_url(get_base_url())
-            .build_public()?;
-        *client_lock = Some(client.clone());
-        Ok(client)
-    } else {
-        Ok(client_lock
-            .as_ref()
-            .expect("Public client should be initialized")
-            .clone())
-    }
-}
-
-/// Get the authenticated client instance (returns None if not authenticated)
-pub fn create_authenticated_client() -> Result<Option<WrappedAuthClient>, ClientError> {
-    let client_lock = AUTH_CLIENT
-        .lock()
-        .expect("Failed to acquire auth client lock");
-    Ok(client_lock.clone())
-}
-
-/// Update the typed clients with an authentication token
-pub fn set_auth_token(token: Option<&str>) -> Result<(), ClientError> {
-    let mut auth_lock = AUTH_CLIENT
-        .lock()
-        .expect("Failed to acquire auth client lock");
-
-    if let Some(token) = token {
-        // Create authenticated client and wrap it
-        let auth_client = TypedClientBuilder::new()
-            .base_url(get_base_url())
-            .build_authenticated(token)?;
-        *auth_lock = Some(WrappedAuthClient::new(auth_client));
-    } else {
-        // Clear authenticated client
-        *auth_lock = None;
-    }
-
-    Ok(())
-}
diff --git a/crates/frontend-common/src/client_wrapper.rs b/crates/frontend-common/src/client_wrapper.rs
deleted file mode 100644
index 8774cd1f..00000000
--- a/crates/frontend-common/src/client_wrapper.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-//! Wrapped client that handles auth errors automatically
-
-use gate_http::client::{
-    error::ClientError,
-    inference_typed::{
-        ChatCompletionRequest, ChatCompletionResponse, MessageRequest, MessageResponse,
-        ModelsResponse,
-    },
-    AuthenticatedGateClient,
-};
-
-/// Wrapper around AuthenticatedGateClient that handles auth errors
-#[derive(Clone)]
-pub struct WrappedAuthClient {
-    inner: AuthenticatedGateClient,
-}
-
-impl WrappedAuthClient {
-    /// Create a new wrapped client
-    pub fn new(client: AuthenticatedGateClient) -> Self {
-        Self { inner: client }
-    }
-
-    /// Execute a request and handle auth errors
-    pub async fn execute<T: serde::de::DeserializeOwned>(
-        &self,
-        request: reqwest::RequestBuilder,
-    ) -> Result<T, ClientError> {
-        match self.inner.execute(request).await {
-            Ok(result) => Ok(result),
-            Err(error) => {
-                // Check if this is an auth error
-                if error.is_auth_expired() {
-                    // Trigger the global auth error handler
-                    crate::auth::error_handler::trigger_auth_error();
-                }
-                Err(error)
-            }
-        }
-    }
-
-    /// Create a request builder with authentication
-    pub fn request(
-        &self,
-        method: reqwest::Method,
-        path: &str,
-    ) -> Result<reqwest::RequestBuilder, ClientError> {
-        self.inner.request(method, path)
-    }
-
-    /// List available models (requires authentication)
-    pub async fn list_models(&self) -> Result<ModelsResponse, ClientError> {
-        let request = self.request(reqwest::Method::GET, "/v1/models")?;
-        self.execute(request).await
-    }
-
-    /// Create a chat completion (requires authentication)
-    pub async fn create_chat_completion(
-        &self,
-        req: ChatCompletionRequest,
-    ) -> Result<ChatCompletionResponse, ClientError> {
-        let request = self
-            .request(reqwest::Method::POST, "/v1/chat/completions")?
-            .json(&req);
-        self.execute(request).await
-    }
-
-    /// Create a message (Anthropic format, requires authentication)
-    pub async fn create_message(
-        &self,
-        req: MessageRequest,
-    ) -> Result<MessageResponse, ClientError> {
-        let request = self
-            .request(reqwest::Method::POST, "/v1/messages")?
-            .json(&req);
-        self.execute(request).await
-    }
-
-    /// Get a reference to the inner client (use sparingly - prefer wrapped methods)
-    pub fn inner(&self) -> &AuthenticatedGateClient {
-        &self.inner
-    }
-}
diff --git a/crates/frontend-common/src/components/bootstrap_prompt.rs b/crates/frontend-common/src/components/bootstrap_prompt.rs
deleted file mode 100644
index db80385f..00000000
--- a/crates/frontend-common/src/components/bootstrap_prompt.rs
+++ /dev/null
@@ -1,153 +0,0 @@
-//! Bootstrap prompt component for initial admin setup
-
-use crate::services::BootstrapStatus;
-use yew::prelude::*;
-
-/// Props for the bootstrap prompt component
-#[derive(Properties, PartialEq)]
-pub struct BootstrapPromptProps {
-    /// Callback when bootstrap token is entered
-    pub on_token: Callback<String>,
-    /// Whether to show the prompt
-    pub show: bool,
-    /// Bootstrap status (optional, passed from container)
-    #[prop_or_default]
-    pub bootstrap_status: Option<BootstrapStatus>,
-    /// Bootstrap token (optional, only shown when provided)
-    #[prop_or_default]
-    pub bootstrap_token: Option<String>,
-    /// Whether token is being loaded
-    #[prop_or_default]
-    pub is_loading_token: bool,
-    /// Token loading error
-    #[prop_or_default]
-    pub token_error: Option<String>,
-}
-
-/// Bootstrap prompt component
-#[function_component(BootstrapPrompt)]
-pub fn bootstrap_prompt(props: &BootstrapPromptProps) -> Html {
-    let token = use_state(String::new);
-    let error = use_state(|| Option::<String>::None);
-
-    // Handle token input
-    let on_token_input = {
-        let token = token.clone();
-        Callback::from(move |e: InputEvent| {
-            let input: web_sys::HtmlInputElement = e.target_unchecked_into();
-            token.set(input.value());
-        })
-    };
-
-    // Submit token
-    let on_submit = {
-        let token = token.clone();
-        let on_token = props.on_token.clone();
-        Callback::from(move |e: SubmitEvent| {
-            e.prevent_default();
-            if !token.is_empty() {
-                on_token.emit((*token).clone());
-            }
-        })
-    };
-
-    if !props.show {
-        return html! {};
-    }
-
-    html! {
-        <div class="fixed inset-0 bg-black/50 backdrop-blur-sm flex items-center justify-center z-50">
-            <div class="bg-white dark:bg-gray-800 rounded-lg p-6 max-w-md w-full mx-4 shadow-xl">
-                <h2 class="text-2xl font-bold mb-4 text-gray-800 dark:text-white">
-                    {"Initial Admin Setup"}
-                </h2>
-
-                {if let Some(status) = &props.bootstrap_status {
-                    html! {
-                        <div class="mb-4 p-4 bg-blue-50 dark:bg-blue-900/20 rounded-lg">
-                            <p class="text-sm text-blue-800 dark:text-blue-200">
-                                {&status.message}
-                            </p>
-                        </div>
-                    }
-                } else {
-                    html! {}
-                }}
-
-                <p class="text-gray-600 dark:text-gray-300 mb-6">
-                    {"This is the first time Gate is being set up. Please enter the bootstrap token to register as the admin user."}
-                </p>
-
-                // Show bootstrap token if available
-                {if let Some(token) = &props.bootstrap_token {
-                    html! {
-                        <div class="mb-6 p-4 bg-blue-50 dark:bg-blue-900/20 rounded-lg">
-                            <p class="text-xs font-semibold text-blue-800 dark:text-blue-200 mb-2">
-                                {"Bootstrap Token (from Tauri app):"}
-                            </p>
-                            <p class="font-mono text-sm break-all select-all text-blue-900 dark:text-blue-100 bg-white dark:bg-gray-800 p-3 rounded">
-                                {token}
-                            </p>
-                            <p class="text-xs text-blue-700 dark:text-blue-300 mt-2">
-                                {"⚠️ This token is single-use only. Copy it now or enter it below."}
-                            </p>
-                        </div>
-                    }
-                } else if props.is_loading_token {
-                    html! {
-                        <div class="mb-4 p-3 bg-gray-100 dark:bg-gray-800 rounded-lg text-center">
-                            <p class="text-sm text-gray-600 dark:text-gray-400">
-                                {"Loading bootstrap token..."}
-                            </p>
-                        </div>
-                    }
-                } else {
-                    html! {}
-                }}
-
-                <form onsubmit={on_submit}>
-                    <div class="mb-4">
-                        <label class="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">
-                            {"Bootstrap Token"}
-                        </label>
-                        <input
-                            type="text"
-                            class="w-full px-4 py-2 border border-gray-300 dark:border-gray-600 rounded-lg bg-white dark:bg-gray-700 text-gray-900 dark:text-white focus:ring-2 focus:ring-blue-500 focus:border-transparent"
-                            placeholder="Enter bootstrap token"
-                            value={(*token).clone()}
-                            oninput={on_token_input}
-                            required=true
-                        />
-                    </div>
-
-
-                    {if let Some(error_msg) = props.token_error.as_ref().or((*error).as_ref()) {
-                        html! {
-                            <div class="mb-4 p-3 bg-red-50 dark:bg-red-900/20 rounded-lg">
-                                <p class="text-sm text-red-800 dark:text-red-200">
-                                    {error_msg}
-                                </p>
-                            </div>
-                        }
-                    } else {
-                        html! {}
-                    }}
-
-                    <button
-                        type="submit"
-                        disabled={token.is_empty()}
-                        class="w-full px-4 py-3 bg-blue-600 text-white rounded-lg hover:bg-blue-700 transition-colors disabled:opacity-50 disabled:cursor-not-allowed font-medium"
-                    >
-                        {"Continue with Setup"}
-                    </button>
-                </form>
-
-                <div class="mt-6 p-4 bg-amber-50 dark:bg-amber-900/20 rounded-lg">
-                    <p class="text-xs text-amber-800 dark:text-amber-200">
-                        <strong>{"Note:"}</strong> {" The bootstrap token is single-use and will be invalidated after the first admin user is created."}
-                    </p>
-                </div>
-            </div>
-        </div>
-    }
-}
diff --git a/crates/frontend-common/src/components/live_chat.rs b/crates/frontend-common/src/components/live_chat.rs
deleted file mode 100644
index 0cd8f45d..00000000
--- a/crates/frontend-common/src/components/live_chat.rs
+++ /dev/null
@@ -1,350 +0,0 @@
-use crate::services::{ChatMessage, InferenceService, Model, Role};
-use gate_chat_ui::{
-    types::{ChatMessage as UIChatMessage, ChatResponse, Provider as UIProvider},
-    ChatContainer,
-};
-use std::collections::HashMap;
-use wasm_bindgen_futures::spawn_local;
-use web_sys::HtmlSelectElement;
-use yew::prelude::*;
-
-#[function_component(LiveChat)]
-pub fn live_chat() -> Html {
-    let messages = use_state(Vec::<UIChatMessage>::new);
-    let loading = use_state(|| false);
-    let error = use_state(|| None::<String>);
-    let selected_model = use_state(|| None::<String>);
-    let available_models = use_state(Vec::<Model>::new);
-    let models_loading = use_state(|| true); // Start as true to indicate initial load
-    let show_settings = use_state(|| true);
-    let manual_model_input = use_state(String::new);
-    let use_manual_model = use_state(|| false);
-
-    // Get the current model name for display
-    let current_model = if *use_manual_model {
-        if manual_model_input.is_empty() {
-            "No model entered".to_string()
-        } else {
-            (*manual_model_input).clone()
-        }
-    } else {
-        selected_model
-            .as_ref()
-            .and_then(|id| available_models.iter().find(|m| m.id == *id))
-            .map(|m| m.id.clone())
-            .unwrap_or_else(|| "No model selected".to_string())
-    };
-
-    // Convert our messages to chat response format
-    let chat_response = ChatResponse {
-        id: "live-chat".to_string(),
-        provider: UIProvider::OpenAI,
-        model: current_model.clone(),
-        messages: (*messages).clone(),
-        usage: None,
-        metadata: HashMap::new(),
-    };
-
-    // Fetch models on component mount
-    {
-        let available_models = available_models.clone();
-        let models_loading = models_loading.clone();
-        let error = error.clone();
-        let selected_model = selected_model.clone();
-
-        use_effect_with((), move |_| {
-            spawn_local(async move {
-                models_loading.set(true);
-                match InferenceService::get_models().await {
-                    Ok(models) => {
-                        web_sys::console::log_1(&format!("Fetched {} models", models.len()).into());
-
-                        // Set Qwen as default if available
-                        if selected_model.is_none() {
-                            if let Some(qwen_model) = models.iter().find(|m| m.id.contains("Qwen"))
-                            {
-                                selected_model.set(Some(qwen_model.id.clone()));
-                                web_sys::console::log_1(
-                                    &format!("Set default model to: {}", qwen_model.id).into(),
-                                );
-                            }
-                        }
-
-                        available_models.set(models);
-                    }
-                    Err(e) => {
-                        // Auth errors are handled automatically by the client wrapper
-                        web_sys::console::error_1(&format!("Failed to fetch models: {e}").into());
-                        error.set(Some(format!("Failed to fetch models: {e}")));
-                    }
-                }
-                models_loading.set(false);
-            });
-        });
-    }
-
-    let on_send_message = {
-        let messages = messages.clone();
-        let loading = loading.clone();
-        let error = error.clone();
-        let selected_model = selected_model.clone();
-        let manual_model_input = manual_model_input.clone();
-        let use_manual_model = use_manual_model.clone();
-
-        Callback::from(move |user_message: String| {
-            if user_message.trim().is_empty() || *loading {
-                return;
-            }
-
-            let model = if *use_manual_model {
-                let manual_model = (*manual_model_input).clone();
-                if manual_model.trim().is_empty() {
-                    error.set(Some("Please enter a model name".to_string()));
-                    return;
-                }
-                manual_model
-            } else {
-                match &*selected_model {
-                    Some(m) => m.clone(),
-                    None => {
-                        error.set(Some(
-                            "Please select a model or enter one manually".to_string(),
-                        ));
-                        return;
-                    }
-                }
-            };
-
-            let messages = messages.clone();
-            let loading = loading.clone();
-            let error = error.clone();
-
-            spawn_local(async move {
-                loading.set(true);
-                error.set(None);
-
-                // Add user message to the chat
-                let mut updated_messages = (*messages).clone();
-                updated_messages.push(UIChatMessage::user(user_message.clone()));
-                messages.set(updated_messages.clone());
-
-                // Prepare messages for API call
-                let api_messages: Vec<ChatMessage> = updated_messages
-                    .iter()
-                    .map(|msg| ChatMessage {
-                        role: match msg.role.as_str() {
-                            "system" => Role::System,
-                            "user" => Role::User,
-                            "assistant" => Role::Assistant,
-                            _ => Role::User,
-                        },
-                        content: msg.get_text_content().unwrap_or_default(),
-                    })
-                    .collect();
-
-                // Detect provider from model
-                let provider = InferenceService::detect_provider(&model);
-
-                // Make API call
-                match InferenceService::chat_completion(
-                    provider,
-                    model.clone(),
-                    api_messages,
-                    Some(0.7),
-                    Some(1000),
-                )
-                .await
-                {
-                    Ok(response) => {
-                        web_sys::console::log_1(&format!("API Response: {response:?}").into());
-
-                        // Parse response based on provider
-                        if let Some(assistant_message) =
-                            InferenceService::parse_response(provider, &response)
-                        {
-                            let mut final_messages = updated_messages.clone();
-                            final_messages.push(UIChatMessage::assistant(assistant_message));
-                            messages.set(final_messages);
-                        } else {
-                            error.set(Some("Failed to parse response".to_string()));
-                            web_sys::console::error_1(
-                                &format!("Failed to parse response: {response:?}").into(),
-                            );
-                        }
-                    }
-                    Err(e) => {
-                        // Auth errors are handled automatically by the client wrapper
-                        error.set(Some(format!("API Error: {e}")));
-                        web_sys::console::error_1(&format!("API Error: {e}").into());
-                        // Remove the user message if the API call failed
-                        messages.set((*messages).clone());
-                    }
-                }
-
-                loading.set(false);
-            });
-        })
-    };
-
-    let on_model_change = {
-        let selected_model = selected_model.clone();
-        Callback::from(move |e: Event| {
-            if let Some(select) = e.target_dyn_into::<HtmlSelectElement>() {
-                let value = select.value();
-                if value.is_empty() {
-                    selected_model.set(None);
-                } else {
-                    selected_model.set(Some(value));
-                }
-            }
-        })
-    };
-
-    let toggle_settings = {
-        let show_settings = show_settings.clone();
-        Callback::from(move |_| {
-            show_settings.set(!*show_settings);
-        })
-    };
-
-    let clear_chat = {
-        let messages = messages.clone();
-        let error = error.clone();
-        Callback::from(move |_| {
-            messages.set(Vec::new());
-            error.set(None);
-        })
-    };
-
-    let on_manual_model_change = {
-        let manual_model_input = manual_model_input.clone();
-        Callback::from(move |e: InputEvent| {
-            if let Some(input) = e.target_dyn_into::<web_sys::HtmlInputElement>() {
-                manual_model_input.set(input.value());
-            }
-        })
-    };
-
-    let on_toggle_manual_model = {
-        let use_manual_model = use_manual_model.clone();
-        Callback::from(move |_| {
-            use_manual_model.set(!*use_manual_model);
-        })
-    };
-
-    html! {
-        <div class="flex h-[calc(100vh-100px)] gap-4 p-4 bg-gray-100 dark:bg-gray-900">
-            if *show_settings {
-                <div class="w-[300px] bg-white dark:bg-gray-800 rounded-lg p-5 shadow-md overflow-y-auto">
-                    <div class="flex justify-between items-center mb-4">
-                        <h2 class="text-xl font-bold text-gray-800 dark:text-gray-200">{"Live Chat Settings"}</h2>
-                        <button
-                            onclick={toggle_settings.clone()}
-                            class="text-gray-600 dark:text-gray-400 hover:text-gray-800 dark:hover:text-gray-200 transition-colors"
-                            title="Hide sidebar"
-                        >
-                            {"× Sidebar"}
-                        </button>
-                    </div>
-
-                    <div class="mb-4">
-                        <label class="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">
-                            {"Model"}
-                        </label>
-
-                        // Toggle button for manual model input
-                        <div class="mb-2">
-                            <button
-                                onclick={on_toggle_manual_model}
-                                class="text-sm text-blue-600 dark:text-blue-400 hover:underline"
-                            >
-                                {if *use_manual_model { "← Use model list" } else { "Enter model manually →" }}
-                            </button>
-                        </div>
-
-                        if *use_manual_model {
-                            // Manual model input
-                            <input
-                                type="text"
-                                placeholder="e.g., gpt-4, claude-3-opus-20240229"
-                                value={(*manual_model_input).clone()}
-                                oninput={on_manual_model_change}
-                                class="w-full p-2 border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-gray-200 rounded text-sm"
-                            />
-                        } else {
-                            // Model selector
-                            if *models_loading {
-                                <div class="w-full p-2 border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-gray-400 rounded text-sm">
-                                    {"Loading models..."}
-                                </div>
-                            } else if available_models.is_empty() {
-                                <div class="w-full p-2 border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-gray-400 rounded text-sm">
-                                    {"No models available"}
-                                </div>
-                            } else {
-                                <select
-                                    onchange={on_model_change}
-                                    class="w-full p-2 border border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-gray-200 rounded text-sm"
-                                    value={selected_model.as_ref().cloned().unwrap_or_default()}
-                                >
-                                    <option value="">{"Select a model"}</option>
-                                    {available_models.iter().map(|model| {
-                                        html! {
-                                            <option value={model.id.clone()} selected={Some(&model.id) == selected_model.as_ref()}>
-                                                {format!("{} ({})", model.id, model.owned_by)}
-                                            </option>
-                                        }
-                                    }).collect::<Html>()}
-                                </select>
-                            }
-                            if !available_models.is_empty() {
-                                <p class="text-xs text-gray-500 dark:text-gray-400 mt-1">
-                                    {format!("{} models available", available_models.len())}
-                                </p>
-                            }
-                        }
-                    </div>
-
-                    <button
-                        onclick={clear_chat}
-                        class="w-full bg-gray-200 hover:bg-gray-300 dark:bg-gray-700 dark:hover:bg-gray-600 text-gray-700 dark:text-gray-300 px-4 py-2 rounded text-sm transition-colors mb-4"
-                    >
-                        {"Clear Chat"}
-                    </button>
-
-                    if let Some(err) = &*error {
-                        <div class="bg-red-50 dark:bg-red-900 text-red-700 dark:text-red-300 p-3 rounded text-sm mb-4">
-                            {err}
-                        </div>
-                    }
-                </div>
-            }
-
-            <div class="flex-1 bg-white dark:bg-gray-800 rounded-lg shadow-md overflow-hidden flex flex-col">
-                <div class="p-3 bg-gray-50 dark:bg-gray-900 border-b border-gray-200 dark:border-gray-700 flex justify-between items-center">
-                    <div class="flex items-center gap-2">
-                        if !*show_settings {
-                            <button
-                                onclick={toggle_settings}
-                                class="text-gray-600 dark:text-gray-400 hover:text-gray-800 dark:hover:text-gray-200 transition-colors"
-                            >
-                                {"☰ Sidebar"}
-                            </button>
-                        }
-                    </div>
-                    if *loading {
-                        <span class="text-sm text-gray-500 dark:text-gray-400">{"Loading..."}</span>
-                    }
-                </div>
-
-                <ChatContainer
-                    chat_response={chat_response}
-                    show_metadata={false}
-                    show_input={true}
-                    on_send_message={on_send_message}
-                    input_disabled={*loading}
-                />
-            </div>
-        </div>
-    }
-}
diff --git a/crates/frontend-common/src/components/mod.rs b/crates/frontend-common/src/components/mod.rs
deleted file mode 100644
index ddfcd8b6..00000000
--- a/crates/frontend-common/src/components/mod.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-mod bootstrap_prompt;
-mod live_chat;
-mod reauth_modal;
-mod spinner;
-mod theme_toggle;
-
-pub use bootstrap_prompt::BootstrapPrompt;
-pub use live_chat::LiveChat;
-pub use reauth_modal::ReauthModal;
-pub use spinner::LoadingSpinner as Spinner;
-pub use theme_toggle::ThemeToggle;
diff --git a/crates/frontend-common/src/components/reauth_modal.rs b/crates/frontend-common/src/components/reauth_modal.rs
deleted file mode 100644
index c75997bc..00000000
--- a/crates/frontend-common/src/components/reauth_modal.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-//! Re-authentication modal component
-
-use crate::auth::{use_auth, AuthAction};
-use crate::hooks::{use_webauthn, WebAuthnState};
-use yew::prelude::*;
-
-/// Re-authentication modal that appears when session expires
-#[function_component(ReauthModal)]
-pub fn reauth_modal() -> Html {
-    let auth = use_auth();
-    let webauthn = use_webauthn();
-    let is_authenticating = use_state(|| false);
-
-    let on_reauth = {
-        let webauthn = webauthn.clone();
-        let is_authenticating = is_authenticating.clone();
-
-        Callback::from(move |e: MouseEvent| {
-            e.prevent_default();
-            is_authenticating.set(true);
-            webauthn.authenticate();
-        })
-    };
-
-    // Monitor WebAuthn state changes
-    {
-        let is_authenticating = is_authenticating.clone();
-
-        use_effect_with(webauthn.state().clone(), move |state| {
-            match state {
-                WebAuthnState::Idle => {
-                    is_authenticating.set(false);
-                }
-                WebAuthnState::Processing => {
-                    // Keep showing loading state
-                }
-                WebAuthnState::Error(_) => {
-                    is_authenticating.set(false);
-                }
-            }
-        });
-    }
-
-    // Auto-hide modal and reload page when authenticated
-    {
-        let auth = auth.clone();
-        use_effect_with(auth.auth_state.clone(), move |auth_state| {
-            if auth_state.is_some() && auth.show_reauth_modal {
-                auth.dispatch(AuthAction::HideReauthModal);
-                // Reload the page to refresh all UI elements
-                if let Some(window) = web_sys::window() {
-                    let _ = window.location().reload();
-                }
-            }
-        });
-    }
-
-    // Only render modal content if show_reauth_modal is true
-    if !auth.show_reauth_modal {
-        return html! {};
-    }
-
-    html! {
-        <div class="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50">
-            <div class="bg-white dark:bg-gray-800 rounded-lg p-6 max-w-md w-full mx-4 shadow-xl">
-                <div class="flex items-center mb-4">
-                    <svg class="w-8 h-8 text-yellow-500 mr-3" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
-                            d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z" />
-                    </svg>
-                    <h2 class="text-xl font-bold text-gray-900 dark:text-white">
-                        {"Session Expired"}
-                    </h2>
-                </div>
-
-                <p class="text-gray-600 dark:text-gray-300 mb-6">
-                    {"Your session has expired. Please re-authenticate to continue using the application."}
-                </p>
-
-                if let Some(error) = &auth.error {
-                    <div class="mb-4 p-3 bg-red-50 dark:bg-red-900/30 text-red-700 dark:text-red-300 rounded text-sm">
-                        {error}
-                    </div>
-                }
-
-                if let WebAuthnState::Error(error) = webauthn.state() {
-                    <div class="mb-4 p-3 bg-red-50 dark:bg-red-900/30 text-red-700 dark:text-red-300 rounded text-sm">
-                        {error}
-                    </div>
-                }
-
-                <button
-                    onclick={on_reauth}
-                    disabled={*is_authenticating}
-                    class="w-full bg-blue-600 hover:bg-blue-700 disabled:bg-gray-400
-                           text-white font-medium py-3 px-4 rounded-lg transition-colors
-                           flex items-center justify-center"
-                >
-                    if *is_authenticating {
-                        <svg class="animate-spin h-5 w-5 mr-2" 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>
-                        {"Authenticating..."}
-                    } else {
-                        <svg class="w-5 h-5 mr-2" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
-                                d="M15 7a2 2 0 012 2m4 0a6 6 0 01-7.743 5.743L11 17H9v2H7v2H4a1 1 0 01-1-1v-2.586a1 1 0 01.293-.707l5.964-5.964A6 6 0 1121 9z" />
-                        </svg>
-                        {"Re-authenticate"}
-                    }
-                </button>
-            </div>
-        </div>
-    }
-}
diff --git a/crates/frontend-common/src/components/spinner.rs b/crates/frontend-common/src/components/spinner.rs
deleted file mode 100644
index 4705d267..00000000
--- a/crates/frontend-common/src/components/spinner.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//! Loading spinner component
-
-use yew::prelude::*;
-
-#[derive(Properties, Clone, PartialEq)]
-pub struct SpinnerProps {
-    #[prop_or_default]
-    pub text: Option<String>,
-}
-
-#[function_component(LoadingSpinner)]
-pub fn loading_spinner(props: &SpinnerProps) -> Html {
-    html! {
-        <div class="text-center p-10">
-            <div class="w-10 h-10 border-4 border-gray-200 dark:border-gray-700 border-t-blue-500 dark:border-t-blue-400 rounded-full animate-spin mx-auto mb-5"></div>
-            if let Some(text) = &props.text {
-                <p class="text-gray-600 dark:text-gray-400 text-sm m-0">{text}</p>
-            }
-        </div>
-    }
-}
diff --git a/crates/frontend-common/src/components/theme_toggle.rs b/crates/frontend-common/src/components/theme_toggle.rs
deleted file mode 100644
index d4d9ca0a..00000000
--- a/crates/frontend-common/src/components/theme_toggle.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-//! Theme toggle component
-
-use crate::theme::{use_current_theme, use_theme_toggle, Theme};
-use yew::prelude::*;
-
-#[function_component(ThemeToggle)]
-pub fn theme_toggle() -> Html {
-    let current_theme = use_current_theme();
-    let toggle = use_theme_toggle();
-
-    let onclick = {
-        let toggle = toggle.clone();
-        Callback::from(move |_| {
-            toggle.emit(());
-        })
-    };
-
-    html! {
-        <button
-            {onclick}
-            class="relative inline-flex items-center justify-center w-10 h-10 p-2 rounded-lg bg-gray-200 dark:bg-gray-700 hover:bg-gray-300 dark:hover:bg-gray-600 transition-colors"
-            aria-label="Toggle theme"
-        >
-            if current_theme == Theme::Light {
-                // Sun icon for light mode
-                <svg class="w-6 h-6 text-yellow-500" fill="currentColor" viewBox="0 0 20 20">
-                    <path fill-rule="evenodd" d="M10 2a1 1 0 011 1v1a1 1 0 11-2 0V3a1 1 0 011-1zm4 8a4 4 0 11-8 0 4 4 0 018 0zm-.464 4.95l.707.707a1 1 0 001.414-1.414l-.707-.707a1 1 0 00-1.414 1.414zm2.12-10.607a1 1 0 010 1.414l-.706.707a1 1 0 11-1.414-1.414l.707-.707a1 1 0 011.414 0zM17 11a1 1 0 100-2h-1a1 1 0 100 2h1zm-7 4a1 1 0 011 1v1a1 1 0 11-2 0v-1a1 1 0 011-1zM5.05 6.464A1 1 0 106.465 5.05l-.708-.707a1 1 0 00-1.414 1.414l.707.707zm1.414 8.486l-.707.707a1 1 0 01-1.414-1.414l.707-.707a1 1 0 011.414 1.414zM4 11a1 1 0 100-2H3a1 1 0 000 2h1z" clip-rule="evenodd"/>
-                </svg>
-            } else {
-                // Moon icon for dark mode
-                <svg class="w-6 h-6 text-blue-300" fill="currentColor" viewBox="0 0 20 20">
-                    <path d="M17.293 13.293A8 8 0 016.707 2.707a8.001 8.001 0 1010.586 10.586z"/>
-                </svg>
-            }
-        </button>
-    }
-}
diff --git a/crates/frontend-common/src/config.rs b/crates/frontend-common/src/config.rs
deleted file mode 100644
index d2424f56..00000000
--- a/crates/frontend-common/src/config.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//! Frontend configuration
-
-/// Authentication configuration
-pub struct AuthConfig;
-
-impl AuthConfig {
-    /// Token refresh interval in milliseconds
-    pub const TOKEN_REFRESH_INTERVAL_MS: u32 = 60_000; // 1 minute
-
-    /// Session storage key for auth state
-    pub const AUTH_STATE_KEY: &'static str = "auth_state";
-}
diff --git a/crates/frontend-common/src/hooks/mod.rs b/crates/frontend-common/src/hooks/mod.rs
deleted file mode 100644
index 9ee07d33..00000000
--- a/crates/frontend-common/src/hooks/mod.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-//! Custom hooks for the application
-
-pub mod use_auth_callback;
-pub mod use_webauthn;
-
-pub use use_webauthn::{use_webauthn, WebAuthnState};
diff --git a/crates/frontend-common/src/hooks/use_auth_callback.rs b/crates/frontend-common/src/hooks/use_auth_callback.rs
deleted file mode 100644
index 6b133667..00000000
--- a/crates/frontend-common/src/hooks/use_auth_callback.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-//! Authentication callback hooks
-
-use crate::auth::use_auth;
-use wasm_bindgen_futures::spawn_local;
-use yew::prelude::*;
-
-/// Hook to create authenticated request callbacks
-/// Use this in components to create callbacks that need auth
-#[hook]
-pub fn use_auth_callback<F, Fut, T>(f: F) -> Callback<T>
-where
-    F: Fn(T, Option<String>) -> Fut + 'static,
-    Fut: std::future::Future<Output = ()> + 'static,
-    T: 'static,
-{
-    let auth = use_auth();
-    let token = auth.auth_state.as_ref().map(|s| s.token.clone());
-
-    Callback::from(move |event: T| {
-        let token = token.clone();
-        let future = f(event, token);
-        spawn_local(future);
-    })
-}
-
-/// Hook to create a simple callback for API requests
-#[hook]
-pub fn use_api_callback<F, Fut>(f: F) -> Callback<MouseEvent>
-where
-    F: Fn(Option<String>) -> Fut + 'static,
-    Fut: std::future::Future<Output = ()> + 'static,
-{
-    use_auth_callback(move |_: MouseEvent, token| f(token))
-}
diff --git a/crates/frontend-common/src/hooks/use_webauthn.rs b/crates/frontend-common/src/hooks/use_webauthn.rs
deleted file mode 100644
index 315d142a..00000000
--- a/crates/frontend-common/src/hooks/use_webauthn.rs
+++ /dev/null
@@ -1,206 +0,0 @@
-//! WebAuthn hook for simplified authentication flows
-
-use crate::auth::context::AuthState;
-use crate::auth::error_messages::get_user_friendly_error;
-use crate::auth::{use_auth, AuthAction};
-use crate::services::{AuthApiService, WebAuthnBrowserService};
-use yew::prelude::*;
-
-/// WebAuthn operation state
-#[derive(Clone, Debug, PartialEq)]
-pub enum WebAuthnState {
-    Idle,
-    Processing,
-    Error(String),
-}
-
-/// WebAuthn hook handle
-#[derive(Clone)]
-pub struct UseWebAuthnHandle {
-    auth_api: AuthApiService,
-    browser_service: WebAuthnBrowserService,
-    auth_context: UseReducerHandle<crate::auth::context::AuthContextData>,
-    state: UseStateHandle<WebAuthnState>,
-}
-
-impl UseWebAuthnHandle {
-    /// Register a new device
-    pub fn register(
-        &self,
-        name: String,
-        device_name: Option<String>,
-        bootstrap_token: Option<String>,
-    ) {
-        let auth_api = self.auth_api.clone();
-        let browser_service = self.browser_service.clone();
-        let auth_context = self.auth_context.clone();
-        let state = self.state.clone();
-
-        wasm_bindgen_futures::spawn_local(async move {
-            state.set(WebAuthnState::Processing);
-
-            // Check WebAuthn support
-            if !browser_service.is_supported() {
-                state.set(WebAuthnState::Error(
-                    "WebAuthn is not supported in this browser".to_string(),
-                ));
-                return;
-            }
-
-            // Start registration
-            match auth_api.start_registration(name).await {
-                Ok(start_response) => {
-                    gloo::console::log!("Registration started, creating credential...");
-
-                    // Create credential
-                    match browser_service
-                        .create_credential(start_response.challenge)
-                        .await
-                    {
-                        Ok(credential) => {
-                            gloo::console::log!("Credential created, completing registration...");
-
-                            // Complete registration
-                            match auth_api
-                                .complete_registration(
-                                    start_response.session_id,
-                                    credential,
-                                    device_name,
-                                    bootstrap_token,
-                                )
-                                .await
-                            {
-                                Ok(complete_response) => {
-                                    gloo::console::log!("Registration successful!");
-
-                                    // Update auth state
-                                    auth_context.dispatch(AuthAction::Login(AuthState {
-                                        user_id: complete_response.user_id,
-                                        name: complete_response.name,
-                                        token: complete_response.token,
-                                        expires_at: None,
-                                    }));
-
-                                    state.set(WebAuthnState::Idle);
-                                }
-                                Err(e) => {
-                                    gloo::console::error!("Registration failed:", &e.to_string());
-                                    state.set(WebAuthnState::Error(get_user_friendly_error(&e)));
-                                }
-                            }
-                        }
-                        Err(e) => {
-                            gloo::console::error!("Credential creation failed:", &e.to_string());
-                            // e is a WebAuthnBrowserError, not ClientError
-                            state.set(WebAuthnState::Error(e.to_string()));
-                        }
-                    }
-                }
-                Err(e) => {
-                    gloo::console::error!("Registration start failed:", &e.to_string());
-                    state.set(WebAuthnState::Error(get_user_friendly_error(&e)));
-                }
-            }
-        });
-    }
-
-    /// Authenticate with an existing device
-    pub fn authenticate(&self) {
-        let auth_api = self.auth_api.clone();
-        let browser_service = self.browser_service.clone();
-        let auth_context = self.auth_context.clone();
-        let state = self.state.clone();
-
-        wasm_bindgen_futures::spawn_local(async move {
-            state.set(WebAuthnState::Processing);
-
-            // Check WebAuthn support
-            if !browser_service.is_supported() {
-                state.set(WebAuthnState::Error(
-                    "WebAuthn is not supported in this browser".to_string(),
-                ));
-                return;
-            }
-
-            // Start authentication
-            match auth_api.start_authentication().await {
-                Ok(start_response) => {
-                    gloo::console::log!("Authentication started, getting credential...");
-
-                    // Get credential
-                    match browser_service
-                        .get_credential(start_response.challenge)
-                        .await
-                    {
-                        Ok(credential) => {
-                            gloo::console::log!(
-                                "Credential obtained, completing authentication..."
-                            );
-
-                            // Complete authentication
-                            match auth_api
-                                .complete_authentication(start_response.session_id, credential)
-                                .await
-                            {
-                                Ok(complete_response) => {
-                                    gloo::console::log!("Authentication successful!");
-
-                                    // Update auth state
-                                    auth_context.dispatch(AuthAction::Login(AuthState {
-                                        user_id: complete_response.user_id,
-                                        name: complete_response.name,
-                                        token: complete_response.token,
-                                        expires_at: None,
-                                    }));
-
-                                    state.set(WebAuthnState::Idle);
-                                }
-                                Err(e) => {
-                                    gloo::console::error!("Authentication failed:", &e.to_string());
-                                    state.set(WebAuthnState::Error(get_user_friendly_error(&e)));
-                                }
-                            }
-                        }
-                        Err(e) => {
-                            gloo::console::error!("Credential get failed:", &e.to_string());
-                            // e is a WebAuthnBrowserError, not ClientError
-                            state.set(WebAuthnState::Error(e.to_string()));
-                        }
-                    }
-                }
-                Err(e) => {
-                    gloo::console::error!("Authentication start failed:", &e.to_string());
-                    state.set(WebAuthnState::Error(get_user_friendly_error(&e)));
-                }
-            }
-        });
-    }
-
-    /// Get the current state
-    pub fn state(&self) -> &WebAuthnState {
-        &self.state
-    }
-
-    /// Clear any error state
-    pub fn clear_error(&self) {
-        if matches!(*self.state, WebAuthnState::Error(_)) {
-            self.state.set(WebAuthnState::Idle);
-        }
-    }
-}
-
-/// Hook to use WebAuthn authentication
-#[hook]
-pub fn use_webauthn() -> UseWebAuthnHandle {
-    let auth_api = use_memo((), |_| AuthApiService::new());
-    let browser_service = use_memo((), |_| WebAuthnBrowserService::new());
-    let auth_context = use_auth();
-    let state = use_state(|| WebAuthnState::Idle);
-
-    UseWebAuthnHandle {
-        auth_api: (*auth_api).clone(),
-        browser_service: (*browser_service).clone(),
-        auth_context,
-        state,
-    }
-}
diff --git a/crates/frontend-common/src/lib.rs b/crates/frontend-common/src/lib.rs
deleted file mode 100644
index b4822521..00000000
--- a/crates/frontend-common/src/lib.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-#![feature(let_chains)]
-
-pub mod auth;
-pub mod client;
-pub mod client_wrapper;
-pub mod components;
-pub mod config;
-pub mod hooks;
-pub mod services;
-pub mod theme;
-
-pub use auth::context::AuthContext;
-pub use client::{create_authenticated_client, create_public_client};
-pub use components::{LiveChat, Spinner, ThemeToggle};
-pub use config::AuthConfig;
-pub use theme::{Theme, ThemeContext, ThemeProvider};
diff --git a/crates/frontend-common/src/services/api_wrapper.rs b/crates/frontend-common/src/services/api_wrapper.rs
deleted file mode 100644
index c5b55916..00000000
--- a/crates/frontend-common/src/services/api_wrapper.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-//! API wrapper utilities for handling authentication errors
-
-use crate::auth::{AuthAction, AuthContext};
-use gate_http::client::error::ClientError;
-
-/// Check if an error is an authentication failure that requires re-authentication
-pub fn handle_api_error(error: &ClientError, auth: &AuthContext) {
-    if error.is_auth_expired() {
-        // Dispatch action to show re-auth modal
-        auth.dispatch(AuthAction::ShowReauthModal);
-    }
-}
-
-/// Wrapper for API calls that handles auth errors
-pub async fn with_auth_error_handling<T, F>(
-    auth: &AuthContext,
-    api_call: F,
-) -> Result<T, ClientError>
-where
-    F: std::future::Future<Output = Result<T, ClientError>>,
-{
-    match api_call.await {
-        Ok(result) => Ok(result),
-        Err(error) => {
-            handle_api_error(&error, auth);
-            Err(error)
-        }
-    }
-}
diff --git a/crates/frontend-common/src/services/auth.rs b/crates/frontend-common/src/services/auth.rs
deleted file mode 100644
index ff15b032..00000000
--- a/crates/frontend-common/src/services/auth.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-//! Authentication API service
-
-use crate::client::{create_public_client, ClientError};
-use gate_http::types::{
-    AuthCompleteRequest, AuthCompleteResponse, AuthStartResponse, RegisterCompleteRequest,
-    RegisterCompleteResponse, RegisterStartResponse,
-};
-/// Authentication API service
-#[derive(Clone)]
-pub struct AuthApiService;
-
-impl AuthApiService {
-    /// Create a new auth API service
-    pub fn new() -> Self {
-        Self
-    }
-}
-
-impl Default for AuthApiService {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl AuthApiService {
-    /// Start registration process
-    pub async fn start_registration(
-        &self,
-        name: String,
-    ) -> Result<RegisterStartResponse, ClientError> {
-        let client = create_public_client()?;
-        let request = gate_http::types::RegisterStartRequest { name };
-        client.register_start(request).await
-    }
-
-    /// Complete registration with the credential
-    pub async fn complete_registration(
-        &self,
-        session_id: String,
-        credential: serde_json::Value,
-        device_name: Option<String>,
-        bootstrap_token: Option<String>,
-    ) -> Result<RegisterCompleteResponse, ClientError> {
-        let client = create_public_client()?;
-
-        let request = RegisterCompleteRequest {
-            session_id,
-            credential,
-            device_name,
-            bootstrap_token: bootstrap_token.clone(),
-        };
-
-        // Use bootstrap endpoint if bootstrap token is present
-        if bootstrap_token.is_some() {
-            client.register_bootstrap(request).await
-        } else {
-            client.register_complete(request).await
-        }
-    }
-
-    /// Start authentication process
-    pub async fn start_authentication(&self) -> Result<AuthStartResponse, ClientError> {
-        let client = create_public_client()?;
-        client.auth_start().await
-    }
-
-    /// Complete authentication with the credential
-    pub async fn complete_authentication(
-        &self,
-        session_id: String,
-        credential: serde_json::Value,
-    ) -> Result<AuthCompleteResponse, ClientError> {
-        let client = create_public_client()?;
-
-        let request = AuthCompleteRequest {
-            session_id,
-            credential,
-        };
-
-        client.auth_complete(request).await
-    }
-}
diff --git a/crates/frontend-common/src/services/bootstrap.rs b/crates/frontend-common/src/services/bootstrap.rs
deleted file mode 100644
index a2162eee..00000000
--- a/crates/frontend-common/src/services/bootstrap.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-//! Bootstrap service for initial admin setup
-
-use crate::client::create_public_client;
-use serde::{Deserialize, Serialize};
-
-/// Bootstrap status response
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct BootstrapStatus {
-    pub needs_bootstrap: bool,
-    pub is_complete: bool,
-    pub message: String,
-}
-
-/// Bootstrap API service
-#[derive(Clone)]
-pub struct BootstrapService;
-
-impl BootstrapService {
-    /// Create a new bootstrap service
-    pub fn new() -> Self {
-        Self
-    }
-
-    /// Check if bootstrap is needed
-    pub async fn check_status(&self) -> Result<BootstrapStatus, String> {
-        let client = create_public_client().map_err(|e| format!("Failed to get client: {e}"))?;
-
-        let request = client
-            .request(reqwest::Method::GET, "/auth/bootstrap/status")
-            .map_err(|e| format!("Failed to check bootstrap status: {e}"))?;
-        let response = request
-            .send()
-            .await
-            .map_err(|e| format!("Failed to check bootstrap status: {e}"))?;
-
-        if !response.status().is_success() {
-            let error_text = response
-                .text()
-                .await
-                .unwrap_or_else(|_| "Unknown error".to_string());
-            return Err(format!("Failed to check bootstrap status: {error_text}"));
-        }
-
-        response
-            .json()
-            .await
-            .map_err(|e| format!("Failed to parse bootstrap status: {e}"))
-    }
-}
-
-impl Default for BootstrapService {
-    fn default() -> Self {
-        Self::new()
-    }
-}
diff --git a/crates/frontend-common/src/services/inference.rs b/crates/frontend-common/src/services/inference.rs
deleted file mode 100644
index f0e701ca..00000000
--- a/crates/frontend-common/src/services/inference.rs
+++ /dev/null
@@ -1,209 +0,0 @@
-//! Inference service for communicating with LLM endpoints
-
-use crate::client::create_authenticated_client;
-use gate_http::client::error::ClientError;
-use serde::{Deserialize, Serialize};
-use serde_json::Value as JsonValue;
-
-/// Message role
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum Role {
-    System,
-    User,
-    Assistant,
-}
-
-/// Chat message
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ChatMessage {
-    pub role: Role,
-    pub content: String,
-}
-
-/// Chat completion request for OpenAI-compatible endpoints
-#[derive(Debug, Clone, Serialize)]
-pub struct ChatCompletionRequest {
-    pub model: String,
-    pub messages: Vec<ChatMessage>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub temperature: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_tokens: Option<u32>,
-    #[serde(default)]
-    pub stream: bool,
-}
-
-/// Anthropic message content
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AnthropicContent {
-    #[serde(rename = "type")]
-    pub content_type: String,
-    pub text: String,
-}
-
-/// Anthropic message format
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AnthropicMessage {
-    pub role: String,
-    pub content: Vec<AnthropicContent>,
-}
-
-/// Anthropic messages request
-#[derive(Debug, Clone, Serialize)]
-pub struct AnthropicMessagesRequest {
-    pub model: String,
-    pub messages: Vec<AnthropicMessage>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_tokens: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub temperature: Option<f32>,
-    #[serde(default)]
-    pub stream: bool,
-}
-
-/// Provider type
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum Provider {
-    OpenAI,
-    Anthropic,
-}
-
-/// Model information from the API
-#[derive(Debug, Clone, Deserialize)]
-pub struct Model {
-    pub id: String,
-    pub owned_by: String,
-}
-
-/// Models list response
-#[derive(Debug, Clone, Deserialize)]
-pub struct ModelsResponse {
-    pub data: Vec<Model>,
-}
-
-/// Inference service for making LLM API calls
-pub struct InferenceService;
-
-impl InferenceService {
-    /// Fetch available models (requires authentication)
-    pub async fn get_models() -> Result<Vec<Model>, ClientError> {
-        // This now requires authentication
-        let client = create_authenticated_client()?
-            .ok_or_else(|| ClientError::Configuration("Not authenticated".into()))?;
-
-        let response = client.list_models().await?;
-        Ok(response
-            .data
-            .into_iter()
-            .map(|m| Model {
-                id: m.id,
-                owned_by: m.owned_by,
-            })
-            .collect())
-    }
-
-    /// Send a chat completion request (requires authentication)
-    pub async fn chat_completion(
-        provider: Provider,
-        model: String,
-        messages: Vec<ChatMessage>,
-        temperature: Option<f32>,
-        max_tokens: Option<u32>,
-    ) -> Result<JsonValue, ClientError> {
-        let client = create_authenticated_client()?
-            .ok_or_else(|| ClientError::Configuration("Not authenticated".into()))?;
-
-        match provider {
-            Provider::OpenAI => {
-                // Build OpenAI-style request
-                let messages = messages
-                    .into_iter()
-                    .map(|msg| gate_http::client::inference_typed::ChatMessage {
-                        role: match msg.role {
-                            Role::System => "system",
-                            Role::User => "user",
-                            Role::Assistant => "assistant",
-                        }
-                        .to_string(),
-                        content: msg.content,
-                    })
-                    .collect();
-
-                let request = gate_http::client::inference_typed::ChatCompletionRequest {
-                    model,
-                    messages,
-                    temperature,
-                    max_tokens,
-                    stream: Some(false),
-                };
-
-                let response = client.create_chat_completion(request).await?;
-                serde_json::to_value(response).map_err(ClientError::Serialization)
-            }
-            Provider::Anthropic => {
-                // Convert messages to Anthropic format
-                let anthropic_messages: Vec<gate_http::client::inference_typed::AnthropicMessage> =
-                    messages
-                        .into_iter()
-                        .filter(|msg| !matches!(msg.role, Role::System)) // Anthropic doesn't use system role in messages
-                        .map(|msg| gate_http::client::inference_typed::AnthropicMessage {
-                            role: match msg.role {
-                                Role::User => "user",
-                                Role::Assistant => "assistant",
-                                Role::System => unreachable!(),
-                            }
-                            .to_string(),
-                            content: msg.content,
-                        })
-                        .collect();
-
-                let request = gate_http::client::inference_typed::MessageRequest {
-                    model,
-                    messages: anthropic_messages,
-                    max_tokens: max_tokens.unwrap_or(1024), // Anthropic requires max_tokens
-                    temperature,
-                    stream: Some(false),
-                    system: None, // TODO: Extract system message if present
-                };
-
-                let response = client.create_message(request).await?;
-                serde_json::to_value(response).map_err(ClientError::Serialization)
-            }
-        }
-    }
-
-    /// Parse response based on provider format
-    pub fn parse_response(provider: Provider, response: &JsonValue) -> Option<String> {
-        match provider {
-            Provider::OpenAI => {
-                // Parse OpenAI response format
-                response
-                    .get("choices")?
-                    .get(0)?
-                    .get("message")?
-                    .get("content")?
-                    .as_str()
-                    .map(|s| s.to_string())
-            }
-            Provider::Anthropic => {
-                // Parse Anthropic response format
-                response
-                    .get("content")?
-                    .get(0)?
-                    .get("text")?
-                    .as_str()
-                    .map(|s| s.to_string())
-            }
-        }
-    }
-
-    /// Detect provider from model name
-    pub fn detect_provider(model: &str) -> Provider {
-        if model.starts_with("claude") {
-            Provider::Anthropic
-        } else {
-            Provider::OpenAI
-        }
-    }
-}
diff --git a/crates/frontend-common/src/services/mod.rs b/crates/frontend-common/src/services/mod.rs
deleted file mode 100644
index fe0fbc81..00000000
--- a/crates/frontend-common/src/services/mod.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-pub mod api_wrapper;
-pub mod auth;
-pub mod bootstrap;
-pub mod inference;
-pub mod webauthn_browser;
-
-pub use api_wrapper::{handle_api_error, with_auth_error_handling};
-pub use auth::AuthApiService;
-pub use bootstrap::{BootstrapService, BootstrapStatus};
-pub use inference::{ChatMessage, InferenceService, Model, Role};
-pub use webauthn_browser::WebAuthnBrowserService;
diff --git a/crates/frontend-common/src/services/webauthn_browser.rs b/crates/frontend-common/src/services/webauthn_browser.rs
deleted file mode 100644
index a2cf81ff..00000000
--- a/crates/frontend-common/src/services/webauthn_browser.rs
+++ /dev/null
@@ -1,389 +0,0 @@
-//! WebAuthn browser API wrapper service
-
-use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
-use serde_json::Value as JsonValue;
-use wasm_bindgen::{JsCast, JsValue};
-use wasm_bindgen_futures::JsFuture;
-use web_sys::{
-    CredentialCreationOptions, CredentialRequestOptions, PublicKeyCredential,
-    PublicKeyCredentialCreationOptions, PublicKeyCredentialRequestOptions,
-};
-/// WebAuthn browser service for credential operations
-#[derive(Clone)]
-pub struct WebAuthnBrowserService;
-
-/// Error type for WebAuthn browser operations
-#[derive(Debug, Clone)]
-pub enum WebAuthnBrowserError {
-    NotSupported,
-    CredentialError(String),
-    ConversionError(String),
-}
-
-impl std::fmt::Display for WebAuthnBrowserError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            WebAuthnBrowserError::NotSupported => write!(f, "WebAuthn is not supported"),
-            WebAuthnBrowserError::CredentialError(msg) => write!(f, "Credential error: {msg}"),
-            WebAuthnBrowserError::ConversionError(msg) => write!(f, "Conversion error: {msg}"),
-        }
-    }
-}
-
-impl WebAuthnBrowserService {
-    /// Create a new WebAuthn browser service
-    pub fn new() -> Self {
-        Self
-    }
-}
-
-impl Default for WebAuthnBrowserService {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl WebAuthnBrowserService {
-    /// Check if WebAuthn is supported
-    pub fn is_supported(&self) -> bool {
-        let window = web_sys::window().expect("No window object available");
-        let navigator = window.navigator();
-
-        // Check if credentials API exists
-        js_sys::Reflect::has(&navigator, &JsValue::from_str("credentials")).unwrap_or(false)
-    }
-
-    /// Create credential from server challenge
-    pub async fn create_credential(
-        &self,
-        challenge_json: JsonValue,
-    ) -> Result<JsonValue, WebAuthnBrowserError> {
-        let window = web_sys::window().ok_or(WebAuthnBrowserError::NotSupported)?;
-        let navigator = window.navigator();
-
-        // Parse the challenge data
-        let options = self.parse_creation_options(challenge_json)?;
-
-        // Create credential
-        let credentials = navigator.credentials();
-
-        let promise = credentials.create_with_options(&options).map_err(|_| {
-            WebAuthnBrowserError::CredentialError("Failed to create credential".to_string())
-        })?;
-
-        let credential = JsFuture::from(promise).await.map_err(|e| {
-            WebAuthnBrowserError::CredentialError(format!("Credential creation failed: {e:?}"))
-        })?;
-
-        let public_key_credential = credential.dyn_into::<PublicKeyCredential>().map_err(|_| {
-            WebAuthnBrowserError::CredentialError("Invalid credential type".to_string())
-        })?;
-
-        self.credential_to_json(&public_key_credential)
-    }
-
-    /// Get credential for authentication
-    pub async fn get_credential(
-        &self,
-        challenge_json: JsonValue,
-    ) -> Result<JsonValue, WebAuthnBrowserError> {
-        let window = web_sys::window().ok_or(WebAuthnBrowserError::NotSupported)?;
-        let navigator = window.navigator();
-
-        // Parse the challenge data
-        let options = self.parse_request_options(challenge_json)?;
-
-        // Get credential
-        let credentials = navigator.credentials();
-
-        let promise = credentials.get_with_options(&options).map_err(|_| {
-            WebAuthnBrowserError::CredentialError("Failed to get credential".to_string())
-        })?;
-
-        let credential = JsFuture::from(promise).await.map_err(|e| {
-            WebAuthnBrowserError::CredentialError(format!("Credential get failed: {e:?}"))
-        })?;
-
-        let public_key_credential = credential.dyn_into::<PublicKeyCredential>().map_err(|_| {
-            WebAuthnBrowserError::CredentialError("Invalid credential type".to_string())
-        })?;
-
-        self.credential_to_json(&public_key_credential)
-    }
-
-    /// Parse creation options from JSON
-    fn parse_creation_options(
-        &self,
-        json: JsonValue,
-    ) -> Result<CredentialCreationOptions, WebAuthnBrowserError> {
-        // Convert JSON to JsValue
-        let js_str = serde_json::to_string(&json).map_err(|e| {
-            WebAuthnBrowserError::ConversionError(format!("Failed to serialize JSON: {e}"))
-        })?;
-        let js_options = js_sys::JSON::parse(&js_str).map_err(|_| {
-            WebAuthnBrowserError::ConversionError("Failed to parse JSON".to_string())
-        })?;
-
-        // Get the publicKey object
-        let public_key = js_sys::Reflect::get(&js_options, &JsValue::from_str("publicKey"))
-            .map_err(|_| {
-                WebAuthnBrowserError::ConversionError("Missing publicKey field".to_string())
-            })?;
-
-        // Convert challenge from base64 to ArrayBuffer
-        let challenge_b64 = js_sys::Reflect::get(&public_key, &JsValue::from_str("challenge"))
-            .map_err(|_| WebAuthnBrowserError::ConversionError("Missing challenge".to_string()))?
-            .as_string()
-            .ok_or_else(|| {
-                WebAuthnBrowserError::ConversionError("Challenge is not a string".to_string())
-            })?;
-
-        let challenge_buffer = self.base64_to_array_buffer(&challenge_b64)?;
-        js_sys::Reflect::set(
-            &public_key,
-            &JsValue::from_str("challenge"),
-            &challenge_buffer,
-        )
-        .map_err(|_| {
-            WebAuthnBrowserError::ConversionError("Failed to set challenge".to_string())
-        })?;
-
-        // Check if we should override the RP ID
-        // Only override for non-relay domains to preserve server's relay-compatible RP ID
-        if let Ok(window) = web_sys::window().ok_or(WebAuthnBrowserError::NotSupported)
-            && let Ok(location) = window.location().hostname()
-            && !location.ends_with(".private.hellas.ai")
-            && !location.ends_with(".public.hellas.ai")
-        {
-            gloo::console::log!(
-                "WebAuthn: Overriding RP ID for non-relay domain:",
-                &location
-            );
-
-            // Create new rp object with current hostname
-            let rp = js_sys::Object::new();
-            js_sys::Reflect::set(&rp, &JsValue::from_str("id"), &JsValue::from_str(&location))
-                .map_err(|_| {
-                    WebAuthnBrowserError::ConversionError("Failed to set rp.id".to_string())
-                })?;
-
-            // Use existing name or default
-            if let Ok(existing_rp) = js_sys::Reflect::get(&public_key, &JsValue::from_str("rp")) {
-                if let Ok(rp_name) = js_sys::Reflect::get(&existing_rp, &JsValue::from_str("name"))
-                {
-                    js_sys::Reflect::set(&rp, &JsValue::from_str("name"), &rp_name).map_err(
-                        |_| {
-                            WebAuthnBrowserError::ConversionError(
-                                "Failed to set rp.name".to_string(),
-                            )
-                        },
-                    )?;
-                }
-            } else {
-                js_sys::Reflect::set(
-                    &rp,
-                    &JsValue::from_str("name"),
-                    &JsValue::from_str("Gate Self-Hosted"),
-                )
-                .map_err(|_| {
-                    WebAuthnBrowserError::ConversionError("Failed to set rp.name".to_string())
-                })?;
-            }
-
-            // Override the rp in publicKey
-            js_sys::Reflect::set(&public_key, &JsValue::from_str("rp"), &rp).map_err(|_| {
-                WebAuthnBrowserError::ConversionError("Failed to override rp".to_string())
-            })?;
-
-            gloo::console::log!("WebAuthn: Overridden RP ID to:", &location);
-        } else if let Ok(window) = web_sys::window().ok_or(WebAuthnBrowserError::NotSupported)
-            && let Ok(location) = window.location().hostname()
-        {
-            // Log that we're using server's RP ID for relay domains
-            gloo::console::log!(
-                "WebAuthn: Using server's RP ID for relay domain:",
-                &location
-            );
-        }
-
-        // Convert user.id from base64 to ArrayBuffer
-        let user = js_sys::Reflect::get(&public_key, &JsValue::from_str("user"))
-            .map_err(|_| WebAuthnBrowserError::ConversionError("Missing user".to_string()))?;
-
-        let user_id_b64 = js_sys::Reflect::get(&user, &JsValue::from_str("id"))
-            .map_err(|_| WebAuthnBrowserError::ConversionError("Missing user.id".to_string()))?
-            .as_string()
-            .ok_or_else(|| {
-                WebAuthnBrowserError::ConversionError("User ID is not a string".to_string())
-            })?;
-
-        let user_id_buffer = self.base64_to_array_buffer(&user_id_b64)?;
-        js_sys::Reflect::set(&user, &JsValue::from_str("id"), &user_id_buffer).map_err(|_| {
-            WebAuthnBrowserError::ConversionError("Failed to set user.id".to_string())
-        })?;
-
-        // Create CredentialCreationOptions and set the publicKey
-        let options = CredentialCreationOptions::new();
-        options.set_public_key(&public_key.unchecked_into::<PublicKeyCredentialCreationOptions>());
-
-        Ok(options)
-    }
-
-    /// Parse request options from JSON
-    fn parse_request_options(
-        &self,
-        json: JsonValue,
-    ) -> Result<CredentialRequestOptions, WebAuthnBrowserError> {
-        // Convert JSON to JsValue
-        let js_str = serde_json::to_string(&json).map_err(|e| {
-            WebAuthnBrowserError::ConversionError(format!("Failed to serialize JSON: {e}"))
-        })?;
-        let js_options = js_sys::JSON::parse(&js_str).map_err(|_| {
-            WebAuthnBrowserError::ConversionError("Failed to parse JSON".to_string())
-        })?;
-
-        // Get the publicKey object
-        let public_key = js_sys::Reflect::get(&js_options, &JsValue::from_str("publicKey"))
-            .map_err(|_| {
-                WebAuthnBrowserError::ConversionError("Missing publicKey field".to_string())
-            })?;
-
-        // Convert challenge from base64 to ArrayBuffer
-        let challenge_b64 = js_sys::Reflect::get(&public_key, &JsValue::from_str("challenge"))
-            .map_err(|_| WebAuthnBrowserError::ConversionError("Missing challenge".to_string()))?
-            .as_string()
-            .ok_or_else(|| {
-                WebAuthnBrowserError::ConversionError("Challenge is not a string".to_string())
-            })?;
-
-        let challenge_buffer = self.base64_to_array_buffer(&challenge_b64)?;
-        js_sys::Reflect::set(
-            &public_key,
-            &JsValue::from_str("challenge"),
-            &challenge_buffer,
-        )
-        .map_err(|_| {
-            WebAuthnBrowserError::ConversionError("Failed to set challenge".to_string())
-        })?;
-
-        // Check if we should override the RP ID
-        // Only override for non-relay domains to preserve server's relay-compatible RP ID
-        if let Ok(window) = web_sys::window().ok_or(WebAuthnBrowserError::NotSupported)
-            && let Ok(location) = window.location().hostname()
-            && !location.ends_with(".private.hellas.ai")
-            && !location.ends_with(".public.hellas.ai")
-        {
-            gloo::console::log!(
-                "WebAuthn: Overriding RP ID for authentication on non-relay domain:",
-                &location
-            );
-
-            // Override the rpId in publicKey
-            js_sys::Reflect::set(
-                &public_key,
-                &JsValue::from_str("rpId"),
-                &JsValue::from_str(&location),
-            )
-            .map_err(|_| {
-                WebAuthnBrowserError::ConversionError("Failed to override rpId".to_string())
-            })?;
-        } else if let Ok(window) = web_sys::window().ok_or(WebAuthnBrowserError::NotSupported)
-            && let Ok(location) = window.location().hostname()
-        {
-            // Log that we're using server's RP ID for relay domains
-            gloo::console::log!(
-                "WebAuthn: Using server's RP ID for authentication on relay domain:",
-                &location
-            );
-        }
-
-        // Convert allowCredentials[].id from base64 to ArrayBuffer if present
-        if let Ok(allow_credentials) =
-            js_sys::Reflect::get(&public_key, &JsValue::from_str("allowCredentials"))
-            && let Some(array) = allow_credentials.dyn_ref::<js_sys::Array>()
-        {
-            for i in 0..array.length() {
-                if let Some(cred) = array.get(i).dyn_ref::<js_sys::Object>()
-                    && let Ok(id_b64) = js_sys::Reflect::get(cred, &JsValue::from_str("id"))
-                    && let Some(id_str) = id_b64.as_string()
-                {
-                    let id_buffer = self.base64_to_array_buffer(&id_str)?;
-                    js_sys::Reflect::set(cred, &JsValue::from_str("id"), &id_buffer).map_err(
-                        |_| {
-                            WebAuthnBrowserError::ConversionError(
-                                "Failed to set credential id".to_string(),
-                            )
-                        },
-                    )?;
-                }
-            }
-        }
-
-        // Create CredentialRequestOptions and set the publicKey
-        let options = CredentialRequestOptions::new();
-        options.set_public_key(&public_key.unchecked_into::<PublicKeyCredentialRequestOptions>());
-
-        Ok(options)
-    }
-
-    /// Convert credential to JSON for sending to server
-    fn credential_to_json(
-        &self,
-        credential: &PublicKeyCredential,
-    ) -> Result<JsonValue, WebAuthnBrowserError> {
-        let response = credential.response();
-
-        let mut json = serde_json::json!({
-            "id": credential.id(),
-            "rawId": self.array_buffer_to_base64(&credential.raw_id()),
-            "type": credential.type_(),
-        });
-
-        // Handle attestation response (for registration)
-        if let Some(attestation) = response.dyn_ref::<web_sys::AuthenticatorAttestationResponse>() {
-            json["response"] = serde_json::json!({
-                "clientDataJSON": self.array_buffer_to_base64(&attestation.client_data_json()),
-                "attestationObject": self.array_buffer_to_base64(&attestation.attestation_object()),
-            });
-        }
-        // Handle assertion response (for authentication)
-        else if let Some(assertion) =
-            response.dyn_ref::<web_sys::AuthenticatorAssertionResponse>()
-        {
-            json["response"] = serde_json::json!({
-                "clientDataJSON": self.array_buffer_to_base64(&assertion.client_data_json()),
-                "authenticatorData": self.array_buffer_to_base64(&assertion.authenticator_data()),
-                "signature": self.array_buffer_to_base64(&assertion.signature()),
-            });
-
-            if let Some(user_handle) = assertion.user_handle() {
-                json["response"]["userHandle"] =
-                    serde_json::Value::String(self.array_buffer_to_base64(&user_handle));
-            }
-        }
-
-        Ok(json)
-    }
-
-    /// Convert ArrayBuffer to base64
-    fn array_buffer_to_base64(&self, buffer: &js_sys::ArrayBuffer) -> String {
-        let array = js_sys::Uint8Array::new(buffer);
-        let bytes: Vec<u8> = array.to_vec();
-        URL_SAFE_NO_PAD.encode(bytes)
-    }
-
-    /// Convert base64 string to ArrayBuffer
-    fn base64_to_array_buffer(
-        &self,
-        base64: &str,
-    ) -> Result<js_sys::ArrayBuffer, WebAuthnBrowserError> {
-        let bytes = URL_SAFE_NO_PAD.decode(base64).map_err(|e| {
-            WebAuthnBrowserError::ConversionError(format!("Base64 decode error: {e}"))
-        })?;
-
-        let array = js_sys::Uint8Array::new_with_length(bytes.len() as u32);
-        array.copy_from(&bytes);
-
-        Ok(array.buffer())
-    }
-}
diff --git a/crates/frontend-common/src/theme/context.rs b/crates/frontend-common/src/theme/context.rs
deleted file mode 100644
index f7f6745c..00000000
--- a/crates/frontend-common/src/theme/context.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-//! Theme context definition
-
-use serde::{Deserialize, Serialize};
-use std::rc::Rc;
-use wasm_bindgen::JsCast;
-use yew::prelude::*;
-
-#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize, Default)]
-pub enum Theme {
-    #[default]
-    Light,
-    Dark,
-}
-
-impl Theme {
-    pub fn toggle(&self) -> Self {
-        match self {
-            Theme::Light => Theme::Dark,
-            Theme::Dark => Theme::Light,
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Default)]
-pub struct ThemeContext {
-    pub theme: Theme,
-}
-
-pub enum ThemeAction {
-    Set(Theme),
-    Toggle,
-}
-
-impl Reducible for ThemeContext {
-    type Action = ThemeAction;
-
-    fn reduce(self: Rc<Self>, action: Self::Action) -> Rc<Self> {
-        match action {
-            ThemeAction::Set(theme) => {
-                // Save to localStorage
-                if let Some(window) = web_sys::window() {
-                    if let Ok(Some(storage)) = window.local_storage() {
-                        let _ = storage
-                            .set_item("theme", &serde_json::to_string(&theme).unwrap_or_default());
-                    }
-                }
-
-                // Update document class
-                update_document_theme(theme);
-
-                Rc::new(Self { theme })
-            }
-            ThemeAction::Toggle => {
-                let new_theme = self.theme.toggle();
-
-                // Save to localStorage
-                if let Some(window) = web_sys::window() {
-                    if let Ok(Some(storage)) = window.local_storage() {
-                        let _ = storage.set_item(
-                            "theme",
-                            &serde_json::to_string(&new_theme).unwrap_or_default(),
-                        );
-                    }
-                }
-
-                // Update document class
-                update_document_theme(new_theme);
-
-                Rc::new(Self { theme: new_theme })
-            }
-        }
-    }
-}
-
-pub fn update_document_theme(theme: Theme) {
-    if let Some(window) = web_sys::window() {
-        if let Some(document) = window.document() {
-            if let Some(element) = document.document_element() {
-                if let Ok(html_element) = element.dyn_into::<web_sys::HtmlElement>() {
-                    let class_list = html_element.class_list();
-                    match theme {
-                        Theme::Dark => {
-                            let _ = class_list.add_1("dark");
-                        }
-                        Theme::Light => {
-                            let _ = class_list.remove_1("dark");
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/crates/frontend-common/src/theme/mod.rs b/crates/frontend-common/src/theme/mod.rs
deleted file mode 100644
index ff4f8877..00000000
--- a/crates/frontend-common/src/theme/mod.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-//! Theme management module
-
-mod context;
-mod provider;
-
-pub use context::{Theme, ThemeAction, ThemeContext};
-pub use provider::ThemeProvider;
-
-use yew::prelude::*;
-
-/// Hook to access theme context
-#[hook]
-pub fn use_theme() -> UseReducerHandle<ThemeContext> {
-    use_context::<UseReducerHandle<ThemeContext>>()
-        .expect("Theme context not found. Make sure to wrap your app with ThemeProvider")
-}
-
-/// Hook to get current theme
-#[hook]
-pub fn use_current_theme() -> Theme {
-    let theme_ctx = use_theme();
-    theme_ctx.theme
-}
-
-/// Hook to get theme toggle callback
-#[hook]
-pub fn use_theme_toggle() -> Callback<()> {
-    let theme_ctx = use_theme();
-    Callback::from(move |_| {
-        theme_ctx.dispatch(ThemeAction::Toggle);
-    })
-}
diff --git a/crates/frontend-common/src/theme/provider.rs b/crates/frontend-common/src/theme/provider.rs
deleted file mode 100644
index d195d6de..00000000
--- a/crates/frontend-common/src/theme/provider.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-//! Theme provider component
-
-use super::context::{Theme, ThemeAction, ThemeContext};
-use wasm_bindgen::JsCast;
-use yew::prelude::*;
-
-#[derive(Properties, Clone, PartialEq)]
-pub struct ThemeProviderProps {
-    pub children: Children,
-}
-
-#[function_component(ThemeProvider)]
-pub fn theme_provider(props: &ThemeProviderProps) -> Html {
-    let theme = use_reducer(|| {
-        // Try to load theme from localStorage
-        let saved_theme = if let Some(window) = web_sys::window() {
-            if let Ok(Some(storage)) = window.local_storage() {
-                if let Ok(Some(theme_str)) = storage.get_item("theme") {
-                    serde_json::from_str(&theme_str).ok()
-                } else {
-                    None
-                }
-            } else {
-                None
-            }
-        } else {
-            None
-        };
-
-        // Use saved theme or default
-        let theme = saved_theme.unwrap_or_default();
-
-        // Apply theme to document
-        if let Some(window) = web_sys::window()
-            && let Some(document) = window.document()
-            && let Some(element) = document.document_element()
-            && let Ok(html_element) = element.dyn_into::<web_sys::HtmlElement>()
-        {
-            let class_list = html_element.class_list();
-            match theme {
-                Theme::Dark => {
-                    let _ = class_list.add_1("dark");
-                }
-                Theme::Light => {
-                    let _ = class_list.remove_1("dark");
-                }
-            }
-        }
-
-        ThemeContext { theme }
-    });
-
-    // Set up system theme preference detection
-    {
-        let theme = theme.clone();
-        use_effect_with((), move |_| {
-            // Only set system preference if no saved theme
-            if let Some(window) = web_sys::window() {
-                if let Ok(Some(storage)) = window.local_storage() {
-                    if storage.get_item("theme").unwrap_or(None).is_none() {
-                        // Check system preference using JavaScript evaluation
-                        if let Ok(matches) = js_sys::eval(
-                    "window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches",
-                ) {
-                    if let Some(dark_mode) = matches.as_bool() {
-                        if dark_mode {
-                            theme.dispatch(ThemeAction::Set(Theme::Dark));
-                        }
-                    }
-                }
-                    }
-                }
-            }
-            || ()
-        });
-    }
-
-    html! {
-        <ContextProvider<UseReducerHandle<ThemeContext>> context={theme}>
-            { props.children.clone() }
-        </ContextProvider<UseReducerHandle<ThemeContext>>>
-    }
-}
diff --git a/crates/frontend-daemon/.gitignore b/crates/frontend-daemon/.gitignore
deleted file mode 100644
index b5dd7e48..00000000
--- a/crates/frontend-daemon/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-dist/
-tailwind.output.css
diff --git a/crates/frontend-daemon/Cargo.toml b/crates/frontend-daemon/Cargo.toml
deleted file mode 100644
index fa071ece..00000000
--- a/crates/frontend-daemon/Cargo.toml
+++ /dev/null
@@ -1,34 +0,0 @@
-[package]
-name = "gate-frontend-daemon"
-version = "0.1.0"
-edition = "2021"
-authors = ["Hellas AI"]
-license = "AGPL-3.0"
-description = "Daemon web UI frontend for Gate"
-
-[dependencies]
-gate-frontend-common = { path = "../frontend-common" }
-gate-chat-ui = { path = "../chat-ui" }
-gloo = { workspace = true, features = ["timers"] }
-wasm-logger = { workspace = true }
-yew = { workspace = true, features = ["csr"] }
-yew-router = { workspace = true }
-web-sys = { workspace = true, features = ["HtmlTextAreaElement", "HtmlLinkElement", "Element", "HtmlHeadElement", "DomTokenList", "Node", "NodeList"] }
-wasm-bindgen = { workspace = true }
-wasm-bindgen-futures = { workspace = true }
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
-serde-wasm-bindgen = { workspace = true }
-chrono = { workspace = true, features = ["serde", "wasmbind"] }
-tracing = "0.1"
-tracing-subscriber = { version = "0.3", features = ["fmt"] }
-tracing-web = { workspace = true }
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-reqwest = { version = "0.12", default-features = false, features = ["json", "stream", "rustls-tls"] }
-
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-reqwest = { version = "0.12", default-features = false, features = ["json", "stream"] }
-getrandom = { workspace = true, features = ["wasm_js"] }
-
-[dev-dependencies]
-wasm-bindgen-test = { workspace = true }
\ No newline at end of file
diff --git a/crates/frontend-daemon/Trunk.toml b/crates/frontend-daemon/Trunk.toml
deleted file mode 100644
index f3dbfe80..00000000
--- a/crates/frontend-daemon/Trunk.toml
+++ /dev/null
@@ -1,25 +0,0 @@
-[[proxy]]
-rewrite = "/auth/"
-backend = "http://localhost:3000/auth/"
-
-[[proxy]]
-rewrite = "/health"
-backend = "http://localhost:3000/health"
-
-[[proxy]]
-rewrite = "/v1/"
-backend = "http://localhost:3000/v1/"
-
-[build]
-target = "index.html"
-dist = "dist"
-
-[[hooks]]
-stage = "pre_build"
-command = "tailwindcss"
-command_arguments = ["-i", "./style.css", "-o", "./tailwind.output.css", "--minify"]
-
-[serve]
-addresses = ["127.0.0.1"]
-port = 8081
-open = false
\ No newline at end of file
diff --git a/crates/frontend-daemon/assets/Hellas_Logotype_Black.svg b/crates/frontend-daemon/assets/Hellas_Logotype_Black.svg
deleted file mode 100644
index 249eec7f..00000000
--- a/crates/frontend-daemon/assets/Hellas_Logotype_Black.svg
+++ /dev/null
@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 27.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 1280 315.64" style="enable-background:new 0 0 1280 315.64;" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#1C1C1C;}
-</style>
-<g>
-	<g>
-		<path class="st0" d="M186,170.44v41.64c0,6.24,2.48,12.23,6.89,16.64l35.49,39.7c2.55,2.55,6.01,3.99,9.62,3.99h15.23
-			c2.25,0,4.07-1.82,4.07-4.07v-23.41c0-2.25-1.82-4.07-4.07-4.07h-30.92c-2.25,0-4.07-1.82-4.07-4.07v-66.34h21.51
-			c2.25,0,4.07-1.82,4.07-4.07v-17.1c0-2.25-1.82-4.07-4.07-4.07h-21.51V78.86c0-2.25,1.82-4.07,4.07-4.07h30.92
-			c2.25,0,4.07-1.82,4.07-4.07V47.3c0-2.25-1.82-4.07-4.07-4.07h-15.23c-3.61,0-7.07,1.43-9.62,3.99l-35.49,39.7
-			c-4.41,4.41-6.89,10.4-6.89,16.64v41.64h-68.53v-41.64c0-6.24-2.48-12.23-6.89-16.64l-35.49-39.7c-2.55-2.55-6.01-3.99-9.62-3.99
-			H50.23c-2.25,0-4.07,1.82-4.07,4.07v23.41c0,2.25,1.82,4.07,4.07,4.07h30.92c2.25,0,4.07,1.82,4.07,4.07v66.34H63.71
-			c-2.25,0-4.07,1.82-4.07,4.07v17.1c0,2.25,1.82,4.07,4.07,4.07h21.51v66.34c0,2.25-1.82,4.07-4.07,4.07H50.23
-			c-2.25,0-4.07,1.82-4.07,4.07v23.41c0,2.25,1.82,4.07,4.07,4.07h15.23c3.61,0,7.07-1.43,9.62-3.99l35.49-39.7
-			c4.41-4.41,6.89-10.4,6.89-16.64v-41.64H186z"/>
-	</g>
-	<g>
-		<path class="st0" d="M461.68,212.41l-32.24-0.34v-41.64H360.9v41.64l-32.24,0.34V103.89l32.24-0.34v41.64h68.54v-41.64l32.24,0.34
-			V212.41z"/>
-		<path class="st0" d="M623.87,212.08H504.65V103.55h119.22v23.94h-87.3v18.51h80.91v22.66h-80.91v18.67h87.3V212.08z"/>
-		<path class="st0" d="M767.81,212.08H666.87V103.55h32.24v83.31h68.7V212.08z"/>
-		<path class="st0" d="M900.11,212.08H799.17V103.55h32.24v83.31h68.7V212.08z"/>
-		<path class="st0" d="M1078.7,212.08h-34.79l-10.05-19.47h-68.46l-9.9,19.47h-34.47l58.89-108.52h39.58L1078.7,212.08z
-			 M1022.21,169.94l-22.34-43.57h-0.8l-22.18,43.57H1022.21z"/>
-		<path class="st0" d="M1233.84,179.2c0,26.97-7.82,34.15-60.96,34.15h-5.11c-61.6,0-67.19-5.43-67.19-32.88v-3.99h31.92v2.87
-			c0,9.1,4.47,10.69,32.88,10.69h3.99c30.96,0,32.88-2.07,32.88-10.05v-0.64c0-8.62-2.23-10.21-34.95-10.21
-			c-60.01,0-65.91-5.43-65.91-32.88v-0.8c0-26.97,8.62-33.2,57.93-33.2h6.54c59.53,0,64.8,7.82,64.8,32.08v3.35h-31.92v-1.76
-			c0-7.82-2.07-10.69-27.93-10.69h-4.79c-30.64,0-33.03,1.28-33.03,10.21v0.64c0,7.82,2.07,8.78,37.66,8.78
-			c55.38,0,63.2,4.63,63.2,33.51V179.2z"/>
-	</g>
-</g>
-</svg>
diff --git a/crates/frontend-daemon/assets/Hellas_Logotype_White.svg b/crates/frontend-daemon/assets/Hellas_Logotype_White.svg
deleted file mode 100644
index ed674e40..00000000
--- a/crates/frontend-daemon/assets/Hellas_Logotype_White.svg
+++ /dev/null
@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 27.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 1280 315.64" style="enable-background:new 0 0 1280 315.64;" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#EAEEF4;}
-</style>
-<g>
-	<g>
-		<path class="st0" d="M186,170.44v41.64c0,6.24,2.48,12.23,6.89,16.64l35.49,39.7c2.55,2.55,6.01,3.99,9.62,3.99h15.23
-			c2.25,0,4.07-1.82,4.07-4.07v-23.41c0-2.25-1.82-4.07-4.07-4.07h-30.92c-2.25,0-4.07-1.82-4.07-4.07v-66.34h21.51
-			c2.25,0,4.07-1.82,4.07-4.07v-17.1c0-2.25-1.82-4.07-4.07-4.07h-21.51V78.86c0-2.25,1.82-4.07,4.07-4.07h30.92
-			c2.25,0,4.07-1.82,4.07-4.07V47.3c0-2.25-1.82-4.07-4.07-4.07h-15.23c-3.61,0-7.07,1.43-9.62,3.99l-35.49,39.7
-			c-4.41,4.41-6.89,10.4-6.89,16.64v41.64h-68.53v-41.64c0-6.24-2.48-12.23-6.89-16.64l-35.49-39.7c-2.55-2.55-6.01-3.99-9.62-3.99
-			H50.23c-2.25,0-4.07,1.82-4.07,4.07v23.41c0,2.25,1.82,4.07,4.07,4.07h30.92c2.25,0,4.07,1.82,4.07,4.07v66.34H63.71
-			c-2.25,0-4.07,1.82-4.07,4.07v17.1c0,2.25,1.82,4.07,4.07,4.07h21.51v66.34c0,2.25-1.82,4.07-4.07,4.07H50.23
-			c-2.25,0-4.07,1.82-4.07,4.07v23.41c0,2.25,1.82,4.07,4.07,4.07h15.23c3.61,0,7.07-1.43,9.62-3.99l35.49-39.7
-			c4.41-4.41,6.89-10.4,6.89-16.64v-41.64H186z"/>
-	</g>
-	<g>
-		<path class="st0" d="M461.68,212.41l-32.24-0.34v-41.64H360.9v41.64l-32.24,0.34V103.89l32.24-0.34v41.64h68.54v-41.64l32.24,0.34
-			V212.41z"/>
-		<path class="st0" d="M623.87,212.08H504.65V103.55h119.22v23.94h-87.3v18.51h80.91v22.66h-80.91v18.67h87.3V212.08z"/>
-		<path class="st0" d="M767.81,212.08H666.87V103.55h32.24v83.31h68.7V212.08z"/>
-		<path class="st0" d="M900.11,212.08H799.17V103.55h32.24v83.31h68.7V212.08z"/>
-		<path class="st0" d="M1078.7,212.08h-34.79l-10.05-19.47h-68.46l-9.9,19.47h-34.47l58.89-108.52h39.58L1078.7,212.08z
-			 M1022.21,169.94l-22.34-43.57h-0.8l-22.18,43.57H1022.21z"/>
-		<path class="st0" d="M1233.84,179.2c0,26.97-7.82,34.15-60.96,34.15h-5.11c-61.6,0-67.19-5.43-67.19-32.88v-3.99h31.92v2.87
-			c0,9.1,4.47,10.69,32.88,10.69h3.99c30.96,0,32.88-2.07,32.88-10.05v-0.64c0-8.62-2.23-10.21-34.95-10.21
-			c-60.01,0-65.91-5.43-65.91-32.88v-0.8c0-26.97,8.62-33.2,57.93-33.2h6.54c59.53,0,64.8,7.82,64.8,32.08v3.35h-31.92v-1.76
-			c0-7.82-2.07-10.69-27.93-10.69h-4.79c-30.64,0-33.03,1.28-33.03,10.21v0.64c0,7.82,2.07,8.78,37.66,8.78
-			c55.38,0,63.2,4.63,63.2,33.51V179.2z"/>
-	</g>
-</g>
-</svg>
diff --git a/crates/frontend-daemon/assets/hellas-token-black.svg b/crates/frontend-daemon/assets/hellas-token-black.svg
deleted file mode 100644
index 6eeb983a..00000000
--- a/crates/frontend-daemon/assets/hellas-token-black.svg
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 27.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 315 315" style="enable-background:new 0 0 315 315;" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#1C1C1C;}
-</style>
-<path class="st0" d="M259.52,106.71l-51.24-51.24c-3.89-3.89-9.06-6.03-14.56-6.03h-72.46c-5.5,0-10.67,2.14-14.55,6.03
-	l-51.24,51.24c-3.89,3.89-6.03,9.06-6.03,14.55v72.46c0,5.5,2.14,10.67,6.03,14.56l51.24,51.24c3.89,3.89,9.06,6.03,14.56,6.03
-	h72.46c5.5,0,10.67-2.14,14.56-6.03l51.24-51.24c3.89-3.89,6.03-9.06,6.03-14.56v-72.46C265.55,115.77,263.41,110.6,259.52,106.71z
-	 M214,110.88c0,1.2-0.98,2.18-2.18,2.18h-16.55c-1.2,0-2.18,0.98-2.18,2.18v35.5h11.51c1.2,0,2.18,0.98,2.18,2.18v9.15
-	c0,1.2-0.98,2.18-2.18,2.18H193.1v35.5c0,1.2,0.98,2.18,2.18,2.18h16.55c1.2,0,2.18,0.98,2.18,2.18v12.53c0,1.2-0.98,2.18-2.18,2.18
-	h-8.15c-1.93,0-3.78-0.77-5.15-2.13l-19-21.25c-2.36-2.36-3.69-5.57-3.69-8.91v-22.29h-36.68v22.29c0,3.34-1.33,6.54-3.69,8.91
-	l-19,21.25c-1.37,1.37-3.22,2.13-5.15,2.13h-8.15c-1.2,0-2.18-0.98-2.18-2.18v-12.53c0-1.2,0.98-2.18,2.18-2.18h16.55
-	c1.2,0,2.18-0.98,2.18-2.18v-35.5h-11.51c-1.2,0-2.18-0.98-2.18-2.18v-9.15c0-1.2,0.98-2.18,2.18-2.18h11.51v-35.5
-	c0-1.2-0.98-2.18-2.18-2.18h-16.55c-1.2,0-2.18-0.98-2.18-2.18V98.35c0-1.2,0.98-2.18,2.18-2.18h8.15c1.93,0,3.78,0.77,5.15,2.13
-	l19,21.25c2.36,2.36,3.69,5.57,3.69,8.91v22.28h36.68v-22.28c0-3.34,1.33-6.54,3.69-8.91l19-21.25c1.37-1.37,3.22-2.13,5.15-2.13
-	h8.15c1.2,0,2.18,0.98,2.18,2.18V110.88z"/>
-</svg>
diff --git a/crates/frontend-daemon/assets/hellas-token-white.svg b/crates/frontend-daemon/assets/hellas-token-white.svg
deleted file mode 100644
index 4e2df956..00000000
--- a/crates/frontend-daemon/assets/hellas-token-white.svg
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 27.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 315 315" style="enable-background:new 0 0 315 315;" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#EAEEF4;}
-</style>
-<path class="st0" d="M259.52,106.71l-51.24-51.24c-3.89-3.89-9.06-6.03-14.56-6.03h-72.46c-5.5,0-10.67,2.14-14.55,6.03
-	l-51.24,51.24c-3.89,3.89-6.03,9.06-6.03,14.55v72.46c0,5.5,2.14,10.67,6.03,14.56l51.24,51.24c3.89,3.89,9.06,6.03,14.56,6.03
-	h72.46c5.5,0,10.67-2.14,14.56-6.03l51.24-51.24c3.89-3.89,6.03-9.06,6.03-14.56v-72.46C265.55,115.77,263.41,110.6,259.52,106.71z
-	 M214,110.88c0,1.2-0.98,2.18-2.18,2.18h-16.55c-1.2,0-2.18,0.98-2.18,2.18v35.5h11.51c1.2,0,2.18,0.98,2.18,2.18v9.15
-	c0,1.2-0.98,2.18-2.18,2.18H193.1v35.5c0,1.2,0.98,2.18,2.18,2.18h16.55c1.2,0,2.18,0.98,2.18,2.18v12.53c0,1.2-0.98,2.18-2.18,2.18
-	h-8.15c-1.93,0-3.78-0.77-5.15-2.13l-19-21.25c-2.36-2.36-3.69-5.57-3.69-8.91v-22.29h-36.68v22.29c0,3.34-1.33,6.54-3.69,8.91
-	l-19,21.25c-1.37,1.37-3.22,2.13-5.15,2.13h-8.15c-1.2,0-2.18-0.98-2.18-2.18v-12.53c0-1.2,0.98-2.18,2.18-2.18h16.55
-	c1.2,0,2.18-0.98,2.18-2.18v-35.5h-11.51c-1.2,0-2.18-0.98-2.18-2.18v-9.15c0-1.2,0.98-2.18,2.18-2.18h11.51v-35.5
-	c0-1.2-0.98-2.18-2.18-2.18h-16.55c-1.2,0-2.18-0.98-2.18-2.18V98.35c0-1.2,0.98-2.18,2.18-2.18h8.15c1.93,0,3.78,0.77,5.15,2.13
-	l19,21.25c2.36,2.36,3.69,5.57,3.69,8.91v22.28h36.68v-22.28c0-3.34,1.33-6.54,3.69-8.91l19-21.25c1.37-1.37,3.22-2.13,5.15-2.13
-	h8.15c1.2,0,2.18,0.98,2.18,2.18V110.88z"/>
-</svg>
diff --git a/crates/frontend-daemon/assets/providers/anthropic.svg b/crates/frontend-daemon/assets/providers/anthropic.svg
deleted file mode 100644
index 472a4e78..00000000
--- a/crates/frontend-daemon/assets/providers/anthropic.svg
+++ /dev/null
@@ -1,4 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" fill="none">
-  <rect width="100" height="100" rx="12" fill="#D97757"/>
-  <text x="50" y="55" font-family="system-ui, -apple-system, sans-serif" font-size="12" font-weight="600" text-anchor="middle" fill="white">Anthropic</text>
-</svg>
\ No newline at end of file
diff --git a/crates/frontend-daemon/assets/providers/cohere.svg b/crates/frontend-daemon/assets/providers/cohere.svg
deleted file mode 100644
index b96aa580..00000000
--- a/crates/frontend-daemon/assets/providers/cohere.svg
+++ /dev/null
@@ -1,4 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" fill="none">
-  <rect width="100" height="100" rx="12" fill="#39C3C4"/>
-  <text x="50" y="55" font-family="system-ui, -apple-system, sans-serif" font-size="14" font-weight="600" text-anchor="middle" fill="white">Cohere</text>
-</svg>
\ No newline at end of file
diff --git a/crates/frontend-daemon/assets/providers/custom.svg b/crates/frontend-daemon/assets/providers/custom.svg
deleted file mode 100644
index e4cec8a2..00000000
--- a/crates/frontend-daemon/assets/providers/custom.svg
+++ /dev/null
@@ -1,4 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" fill="none">
-  <rect width="100" height="100" rx="12" fill="#6B7280"/>
-  <text x="50" y="55" font-family="system-ui, -apple-system, sans-serif" font-size="14" font-weight="600" text-anchor="middle" fill="white">Custom</text>
-</svg>
\ No newline at end of file
diff --git a/crates/frontend-daemon/assets/providers/gemini.svg b/crates/frontend-daemon/assets/providers/gemini.svg
deleted file mode 100644
index f2654e18..00000000
--- a/crates/frontend-daemon/assets/providers/gemini.svg
+++ /dev/null
@@ -1,4 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" fill="none">
-  <rect width="100" height="100" rx="12" fill="#4285F4"/>
-  <text x="50" y="55" font-family="system-ui, -apple-system, sans-serif" font-size="14" font-weight="600" text-anchor="middle" fill="white">Gemini</text>
-</svg>
\ No newline at end of file
diff --git a/crates/frontend-daemon/assets/providers/groq.svg b/crates/frontend-daemon/assets/providers/groq.svg
deleted file mode 100644
index f87e53a4..00000000
--- a/crates/frontend-daemon/assets/providers/groq.svg
+++ /dev/null
@@ -1,4 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" fill="none">
-  <rect width="100" height="100" rx="12" fill="#F55036"/>
-  <text x="50" y="55" font-family="system-ui, -apple-system, sans-serif" font-size="14" font-weight="600" text-anchor="middle" fill="white">Groq</text>
-</svg>
\ No newline at end of file
diff --git a/crates/frontend-daemon/assets/providers/mistral.svg b/crates/frontend-daemon/assets/providers/mistral.svg
deleted file mode 100644
index c266ded0..00000000
--- a/crates/frontend-daemon/assets/providers/mistral.svg
+++ /dev/null
@@ -1,4 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" fill="none">
-  <rect width="100" height="100" rx="12" fill="#F7B731"/>
-  <text x="50" y="55" font-family="system-ui, -apple-system, sans-serif" font-size="14" font-weight="600" text-anchor="middle" fill="white">Mistral</text>
-</svg>
\ No newline at end of file
diff --git a/crates/frontend-daemon/assets/providers/openai.svg b/crates/frontend-daemon/assets/providers/openai.svg
deleted file mode 100644
index d1d245cd..00000000
--- a/crates/frontend-daemon/assets/providers/openai.svg
+++ /dev/null
@@ -1,4 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" fill="none">
-  <rect width="100" height="100" rx="12" fill="#74AA9C"/>
-  <text x="50" y="55" font-family="system-ui, -apple-system, sans-serif" font-size="14" font-weight="600" text-anchor="middle" fill="white">OpenAI</text>
-</svg>
\ No newline at end of file
diff --git a/crates/frontend-daemon/assets/providers/perplexity.svg b/crates/frontend-daemon/assets/providers/perplexity.svg
deleted file mode 100644
index ca43c613..00000000
--- a/crates/frontend-daemon/assets/providers/perplexity.svg
+++ /dev/null
@@ -1,4 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" fill="none">
-  <rect width="100" height="100" rx="12" fill="#20B0B3"/>
-  <text x="50" y="55" font-family="system-ui, -apple-system, sans-serif" font-size="12" font-weight="600" text-anchor="middle" fill="white">Perplexity</text>
-</svg>
\ No newline at end of file
diff --git a/crates/frontend-daemon/favicon.ico b/crates/frontend-daemon/favicon.ico
deleted file mode 100644
index bdb619ad..00000000
Binary files a/crates/frontend-daemon/favicon.ico and /dev/null differ
diff --git a/crates/frontend-daemon/favicon.png b/crates/frontend-daemon/favicon.png
deleted file mode 100644
index e0a261c8..00000000
Binary files a/crates/frontend-daemon/favicon.png and /dev/null differ
diff --git a/crates/frontend-daemon/index.html b/crates/frontend-daemon/index.html
deleted file mode 100644
index 5347b276..00000000
--- a/crates/frontend-daemon/index.html
+++ /dev/null
@@ -1,14 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>Gate Frontend</title>
-    <link rel="icon" type="image/svg+xml" href="/assets/hellas-token-black.svg" id="favicon">
-    <link data-trunk rel="copy-dir" href="assets" />
-    <link data-trunk rel="css" href="tailwind.output.css" />
-</head>
-<body class="bg-white dark:bg-gray-900">
-    <div id="app"></div>
-</body>
-</html>
diff --git a/crates/frontend-daemon/src/components/config_editor/auth.rs b/crates/frontend-daemon/src/components/config_editor/auth.rs
deleted file mode 100644
index e7043ebd..00000000
--- a/crates/frontend-daemon/src/components/config_editor/auth.rs
+++ /dev/null
@@ -1,207 +0,0 @@
-use yew::prelude::*;
-
-use super::shared::{ConfigField, ConfigInput, ConfigSection, ConfigToggle};
-use super::types::AuthConfig;
-
-#[derive(Properties, PartialEq)]
-pub struct AuthConfigSectionProps {
-    pub config: AuthConfig,
-    pub on_change: Callback<AuthConfig>,
-}
-
-#[function_component(AuthConfigSection)]
-pub fn auth_config_section(props: &AuthConfigSectionProps) -> Html {
-    let config = props.config.clone();
-
-    let on_rp_id_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            let mut new_config = config.clone();
-            new_config.webauthn.rp_id = value;
-            on_change.emit(new_config);
-        })
-    };
-
-    let on_rp_name_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            let mut new_config = config.clone();
-            new_config.webauthn.rp_name = value;
-            on_change.emit(new_config);
-        })
-    };
-
-    let on_rp_origin_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            let mut new_config = config.clone();
-            new_config.webauthn.rp_origin = value;
-            on_change.emit(new_config);
-        })
-    };
-
-    let on_allowed_origins_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            let mut new_config = config.clone();
-            new_config.webauthn.allowed_origins = value
-                .split(',')
-                .map(|s| s.trim().to_string())
-                .filter(|s| !s.is_empty())
-                .collect();
-            on_change.emit(new_config);
-        })
-    };
-
-    let on_jwt_issuer_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            let mut new_config = config.clone();
-            new_config.jwt.issuer = value;
-            on_change.emit(new_config);
-        })
-    };
-
-    let on_jwt_secret_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            let mut new_config = config.clone();
-            new_config.jwt.secret = value;
-            on_change.emit(new_config);
-        })
-    };
-
-    let on_jwt_expiration_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            if let Ok(hours) = value.parse::<u64>() {
-                let mut new_config = config.clone();
-                new_config.jwt.expiration_hours = hours;
-                on_change.emit(new_config);
-            }
-        })
-    };
-
-    let on_open_registration_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: bool| {
-            let mut new_config = config.clone();
-            new_config.registration.allow_open_registration = value;
-            on_change.emit(new_config);
-        })
-    };
-
-    html! {
-        <ConfigSection title="Authentication Configuration">
-            <div class="space-y-6">
-                <ConfigSection
-                    title="WebAuthn Settings"
-                >
-                    <ConfigField
-                        label="Relying Party ID"
-                        help_text="Usually your domain name (e.g., example.com)"
-                    >
-                        <ConfigInput
-                            value={props.config.webauthn.rp_id.clone()}
-                            on_change={on_rp_id_change}
-                            placeholder="localhost"
-                        />
-                    </ConfigField>
-
-                    <ConfigField
-                        label="Relying Party Name"
-                        help_text="Display name for your application"
-                    >
-                        <ConfigInput
-                            value={props.config.webauthn.rp_name.clone()}
-                            on_change={on_rp_name_change}
-                            placeholder="Gate Self-Hosted"
-                        />
-                    </ConfigField>
-
-                    <ConfigField
-                        label="Relying Party Origin"
-                        help_text="Full URL of your application"
-                    >
-                        <ConfigInput
-                            value={props.config.webauthn.rp_origin.clone()}
-                            on_change={on_rp_origin_change}
-                            placeholder="http://localhost:31145"
-                        />
-                    </ConfigField>
-
-                    <ConfigField
-                        label="Additional Allowed Origins"
-                        help_text="Comma-separated list of additional allowed origins"
-                    >
-                        <ConfigInput
-                            value={props.config.webauthn.allowed_origins.join(", ")}
-                            on_change={on_allowed_origins_change}
-                            placeholder="https://app.example.com, https://beta.example.com"
-                        />
-                    </ConfigField>
-                </ConfigSection>
-
-                <div>
-                    <h4 class="text-sm font-medium text-gray-700 dark:text-gray-300 mb-3">{"JWT Settings"}</h4>
-                    <div class="pl-4 space-y-3">
-                        <ConfigField
-                            label="JWT Issuer"
-                            help_text="Issuer identifier for JWT tokens"
-                        >
-                            <ConfigInput
-                                value={props.config.jwt.issuer.clone()}
-                                on_change={on_jwt_issuer_change}
-                                placeholder="gate-daemon"
-                            />
-                        </ConfigField>
-
-                        <ConfigField
-                            label="JWT Secret"
-                            help_text="Secret key for signing JWT tokens (keep this secure!)"
-                        >
-                            <ConfigInput
-                                value={props.config.jwt.secret.clone()}
-                                on_change={on_jwt_secret_change}
-                                input_type="password"
-                                placeholder="Your secret key"
-                            />
-                        </ConfigField>
-
-                        <ConfigField
-                            label="Token Expiration (hours)"
-                            help_text="How long JWT tokens remain valid"
-                        >
-                            <ConfigInput
-                                value={props.config.jwt.expiration_hours.to_string()}
-                                on_change={on_jwt_expiration_change}
-                                input_type="number"
-                                placeholder="24"
-                            />
-                        </ConfigField>
-                    </div>
-                </div>
-
-                <div>
-                    <h4 class="text-sm font-medium text-gray-700 dark:text-gray-300 mb-3">{"Registration Settings"}</h4>
-                    <div class="pl-4">
-                        <ConfigToggle
-                            label="Allow Open Registration"
-                            checked={props.config.registration.allow_open_registration}
-                            on_change={on_open_registration_change}
-                            help_text="Allow new users to register without an invitation"
-                        />
-                    </div>
-                </div>
-            </div>
-        </ConfigSection>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/config_editor/container.rs b/crates/frontend-daemon/src/components/config_editor/container.rs
deleted file mode 100644
index 172543d5..00000000
--- a/crates/frontend-daemon/src/components/config_editor/container.rs
+++ /dev/null
@@ -1,240 +0,0 @@
-use crate::services::ConfigApiService;
-use gloo::timers::callback::Timeout;
-use yew::prelude::*;
-
-use super::{
-    pages::{
-        AuthConfigPage, InferenceConfigPage, NetworkConfigPage, ProvidersConfigPage,
-        ServerConfigPage,
-    },
-    sub_nav::{ConfigPage, SubNav},
-    types::*,
-};
-
-#[function_component(ConfigEditor)]
-pub fn config_editor() -> Html {
-    let config_service = use_memo((), |_| ConfigApiService::new());
-    let config = use_state(GateConfig::default);
-    let is_loading = use_state(|| false);
-    let is_saving = use_state(|| false);
-    let error_message = use_state(|| None::<String>);
-    let success_message = use_state(|| None::<String>);
-    let active_page = use_state(|| ConfigPage::Server);
-
-    {
-        let config_service = config_service.clone();
-        let config = config.clone();
-        let is_loading = is_loading.clone();
-        let error_message = error_message.clone();
-
-        use_effect_with((), move |_| {
-            is_loading.set(true);
-            wasm_bindgen_futures::spawn_local(async move {
-                match config_service.get_config().await {
-                    Ok(config_json) => match serde_json::from_value::<GateConfig>(config_json) {
-                        Ok(loaded_config) => config.set(loaded_config),
-                        Err(e) => error_message.set(Some(format!("Failed to parse config: {e}"))),
-                    },
-                    Err(e) => error_message.set(Some(format!("Failed to load config: {e}"))),
-                }
-                is_loading.set(false);
-            });
-        });
-    }
-
-    let on_save = {
-        let config_service = config_service.clone();
-        let config = config.clone();
-        let is_saving = is_saving.clone();
-        let error_message = error_message.clone();
-        let success_message = success_message.clone();
-
-        Callback::from(move |_| {
-            is_saving.set(true);
-            error_message.set(None);
-
-            let config_json = match serde_json::to_value(&*config) {
-                Ok(json) => json,
-                Err(e) => {
-                    error_message.set(Some(format!("Failed to serialize config: {e}")));
-                    is_saving.set(false);
-                    return;
-                }
-            };
-
-            let config_service = config_service.clone();
-            let is_saving = is_saving.clone();
-            let error_message = error_message.clone();
-            let success_message = success_message.clone();
-
-            wasm_bindgen_futures::spawn_local(async move {
-                match config_service.update_config(config_json).await {
-                    Ok(_) => {
-                        success_message.set(Some("Configuration saved successfully!".to_string()));
-                        let success_message = success_message.clone();
-                        Timeout::new(3000, move || {
-                            success_message.set(None);
-                        })
-                        .forget();
-                    }
-                    Err(e) => error_message.set(Some(format!("Failed to save config: {e}"))),
-                }
-                is_saving.set(false);
-            });
-        })
-    };
-
-    let on_server_change = {
-        let config = config.clone();
-        Callback::from(move |new_server| {
-            let mut new_config = (*config).clone();
-            new_config.server = new_server;
-            config.set(new_config);
-        })
-    };
-
-    let on_auth_change = {
-        let config = config.clone();
-        Callback::from(move |new_auth| {
-            let mut new_config = (*config).clone();
-            new_config.auth = new_auth;
-            config.set(new_config);
-        })
-    };
-
-    let on_providers_change = {
-        let config = config.clone();
-        Callback::from(move |new_providers| {
-            let mut new_config = (*config).clone();
-            new_config.providers = new_providers;
-            config.set(new_config);
-        })
-    };
-
-    let on_tlsforward_change = {
-        let config = config.clone();
-        Callback::from(move |new_tlsforward| {
-            let mut new_config = (*config).clone();
-            new_config.tlsforward = new_tlsforward;
-            config.set(new_config);
-        })
-    };
-
-    let on_letsencrypt_change = {
-        let config = config.clone();
-        Callback::from(move |new_letsencrypt| {
-            let mut new_config = (*config).clone();
-            new_config.letsencrypt = new_letsencrypt;
-            config.set(new_config);
-        })
-    };
-
-    let on_inference_change = {
-        let config = config.clone();
-        Callback::from(move |new_inference| {
-            let mut new_config = (*config).clone();
-            new_config.local_inference = new_inference;
-            config.set(new_config);
-        })
-    };
-
-    let on_page_change = {
-        let active_page = active_page.clone();
-        Callback::from(move |page| {
-            active_page.set(page);
-        })
-    };
-
-    html! {
-        <div class="p-6 max-w-6xl mx-auto">
-            <div class="bg-white dark:bg-gray-800 rounded-lg shadow-lg">
-                <div class="border-b border-gray-200 dark:border-gray-700 px-6 py-4">
-                    <h2 class="text-xl font-semibold text-gray-800 dark:text-gray-200">
-                        {"Configuration Editor"}
-                    </h2>
-                    <p class="text-sm text-gray-600 dark:text-gray-400 mt-1">
-                        {"Manage Gate configuration settings"}
-                    </p>
-                </div>
-
-                <div class="p-6">
-                    if *is_loading {
-                        <div class="flex justify-center items-center h-64">
-                            <div class="animate-spin rounded-full h-8 w-8 border-b-2 border-blue-500"></div>
-                        </div>
-                    } else {
-                        <>
-                            if let Some(error) = (*error_message).as_ref() {
-                                <div class="mb-4 p-4 bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 rounded-md">
-                                    <p class="text-red-700 dark:text-red-300">{error}</p>
-                                </div>
-                            }
-
-                            if let Some(success) = (*success_message).as_ref() {
-                                <div class="mb-4 p-4 bg-green-50 dark:bg-green-900/20 border border-green-200 dark:border-green-800 rounded-md">
-                                    <p class="text-green-700 dark:text-green-300">{success}</p>
-                                </div>
-                            }
-
-                            <SubNav
-                                active_page={*active_page}
-                                on_change={on_page_change}
-                            />
-
-                            <div class="overflow-y-auto">
-                                {match *active_page {
-                                    ConfigPage::Server => html! {
-                                        <ServerConfigPage
-                                            config={config.server.clone()}
-                                            on_change={on_server_change}
-                                        />
-                                    },
-                                    ConfigPage::Authentication => html! {
-                                        <AuthConfigPage
-                                            config={config.auth.clone()}
-                                            on_change={on_auth_change}
-                                        />
-                                    },
-                                    ConfigPage::Providers => html! {
-                                        <ProvidersConfigPage
-                                            providers={config.providers.clone()}
-                                            on_change={on_providers_change}
-                                        />
-                                    },
-                                    ConfigPage::Network => html! {
-                                        <NetworkConfigPage
-                                            tlsforward={config.tlsforward.clone()}
-                                            letsencrypt={config.letsencrypt.clone()}
-                                            on_tlsforward_change={on_tlsforward_change}
-                                            on_letsencrypt_change={on_letsencrypt_change}
-                                        />
-                                    },
-                                    ConfigPage::Inference => html! {
-                                        <InferenceConfigPage
-                                            config={config.local_inference.clone()}
-                                            on_change={on_inference_change}
-                                        />
-                                    },
-                                }}
-                            </div>
-
-                            <div class="mt-6 flex justify-end">
-                                <button
-                                    class="px-4 py-2 bg-blue-500 hover:bg-blue-600 text-white rounded-md transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
-                                    onclick={on_save}
-                                    disabled={*is_saving}
-                                >
-                                    if *is_saving {
-                                        {"Saving..."}
-                                    } else {
-                                        {"Save Configuration"}
-                                    }
-                                </button>
-                            </div>
-                        </>
-                    }
-                </div>
-            </div>
-        </div>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/config_editor/inference.rs b/crates/frontend-daemon/src/components/config_editor/inference.rs
deleted file mode 100644
index 1c8ad49c..00000000
--- a/crates/frontend-daemon/src/components/config_editor/inference.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-use yew::prelude::*;
-
-use super::shared::{ConfigField, ConfigInput, ConfigSection};
-use super::types::LocalInferenceConfig;
-
-#[derive(Properties, PartialEq)]
-pub struct InferenceConfigSectionProps {
-    pub config: Option<LocalInferenceConfig>,
-    pub on_change: Callback<Option<LocalInferenceConfig>>,
-}
-
-#[function_component(InferenceConfigSection)]
-pub fn inference_config_section(props: &InferenceConfigSectionProps) -> Html {
-    let enabled = props.config.is_some();
-    let config = props.config.clone().unwrap_or_default();
-
-    let on_enabled_toggle = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: bool| {
-            if value {
-                on_change.emit(Some(config.clone()));
-            } else {
-                on_change.emit(None);
-            }
-        })
-    };
-
-    let on_max_concurrent_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            if let Ok(max_concurrent) = value.parse::<usize>() {
-                let mut new_config = config.clone();
-                new_config.max_concurrent_inferences = max_concurrent;
-                on_change.emit(Some(new_config));
-            }
-        })
-    };
-
-    let on_temperature_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            if let Ok(temp) = value.parse::<f32>() {
-                if (0.0..=2.0).contains(&temp) {
-                    let mut new_config = config.clone();
-                    new_config.default_temperature = temp;
-                    on_change.emit(Some(new_config));
-                }
-            }
-        })
-    };
-
-    let on_max_tokens_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            if let Ok(max_tokens) = value.parse::<u32>() {
-                let mut new_config = config.clone();
-                new_config.default_max_tokens = max_tokens;
-                on_change.emit(Some(new_config));
-            }
-        })
-    };
-
-    html! {
-        <ConfigSection
-            title="Local Inference Configuration"
-            enabled={enabled}
-            on_toggle={on_enabled_toggle}
-        >
-            <ConfigField
-                label="Maximum Concurrent Inferences"
-                help_text="Number of inference requests that can be processed simultaneously"
-            >
-                <ConfigInput
-                    value={config.max_concurrent_inferences.to_string()}
-                    on_change={on_max_concurrent_change}
-                    input_type="number"
-                    placeholder="4"
-                />
-            </ConfigField>
-
-            <ConfigField
-                label="Default Temperature"
-                help_text="Controls randomness in model output (0.0 - 2.0)"
-            >
-                <ConfigInput
-                    value={config.default_temperature.to_string()}
-                    on_change={on_temperature_change}
-                    input_type="number"
-                    placeholder="0.7"
-                />
-            </ConfigField>
-
-            <ConfigField
-                label="Default Maximum Tokens"
-                help_text="Maximum number of tokens to generate in responses"
-            >
-                <ConfigInput
-                    value={config.default_max_tokens.to_string()}
-                    on_change={on_max_tokens_change}
-                    input_type="number"
-                    placeholder="2048"
-                />
-            </ConfigField>
-        </ConfigSection>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/config_editor/letsencrypt.rs b/crates/frontend-daemon/src/components/config_editor/letsencrypt.rs
deleted file mode 100644
index 0af52493..00000000
--- a/crates/frontend-daemon/src/components/config_editor/letsencrypt.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-use yew::prelude::*;
-
-use super::shared::{ConfigField, ConfigInput, ConfigSection, ConfigToggle};
-use super::types::LetsEncryptConfig;
-
-#[derive(Properties, PartialEq)]
-pub struct LetsEncryptConfigSectionProps {
-    pub config: LetsEncryptConfig,
-    pub on_change: Callback<LetsEncryptConfig>,
-}
-
-#[function_component(LetsEncryptConfigSection)]
-pub fn letsencrypt_config_section(props: &LetsEncryptConfigSectionProps) -> Html {
-    let config = props.config.clone();
-
-    let on_enabled_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: bool| {
-            let mut new_config = config.clone();
-            new_config.enabled = value;
-            on_change.emit(new_config);
-        })
-    };
-
-    let on_email_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            let mut new_config = config.clone();
-            new_config.email = if value.is_empty() { None } else { Some(value) };
-            on_change.emit(new_config);
-        })
-    };
-
-    let on_staging_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: bool| {
-            let mut new_config = config.clone();
-            new_config.staging = value;
-            on_change.emit(new_config);
-        })
-    };
-
-    let on_domains_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            let mut new_config = config.clone();
-            new_config.domains = value
-                .lines()
-                .map(|s| s.trim().to_string())
-                .filter(|s| !s.is_empty())
-                .collect();
-            on_change.emit(new_config);
-        })
-    };
-
-    let on_auto_renew_days_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            if let Ok(days) = value.parse::<u32>() {
-                let mut new_config = config.clone();
-                new_config.auto_renew_days = days;
-                on_change.emit(new_config);
-            }
-        })
-    };
-
-    html! {
-        <ConfigSection
-            title="Let's Encrypt Configuration"
-            enabled={props.config.enabled}
-            on_toggle={on_enabled_change}
-        >
-            <ConfigField
-                label="Email Address"
-                help_text="Email for Let's Encrypt account and notifications"
-            >
-                <ConfigInput
-                    value={props.config.email.clone().unwrap_or_default()}
-                    on_change={on_email_change}
-                    input_type="email"
-                    placeholder="admin@example.com"
-                />
-            </ConfigField>
-
-            <ConfigToggle
-                label="Use Staging Environment"
-                checked={props.config.staging}
-                on_change={on_staging_change}
-                help_text="Use Let's Encrypt staging servers for testing (certificates won't be trusted)"
-            />
-
-            <ConfigField
-                label="Domains"
-                help_text="Domain names to request certificates for (one per line)"
-            >
-                <textarea
-                    class="w-full px-2.5 py-1.5 text-sm border border-gray-300 dark:border-gray-600 rounded-md shadow-sm
-                           focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500
-                           bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100"
-                    rows="2"
-                    value={props.config.domains.join("\n")}
-                    oninput={Callback::from(move |e: InputEvent| {
-                        let input: web_sys::HtmlTextAreaElement = e.target_unchecked_into();
-                        on_domains_change.emit(input.value());
-                    })}
-                    placeholder={"example.com\nwww.example.com\napi.example.com"}
-                />
-            </ConfigField>
-
-            <ConfigField
-                label="Auto-Renew Days Before Expiry"
-                help_text="Number of days before certificate expiry to attempt renewal"
-            >
-                <ConfigInput
-                    value={props.config.auto_renew_days.to_string()}
-                    on_change={on_auto_renew_days_change}
-                    input_type="number"
-                    placeholder="30"
-                />
-            </ConfigField>
-        </ConfigSection>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/config_editor/mod.rs b/crates/frontend-daemon/src/components/config_editor/mod.rs
deleted file mode 100644
index 14d11540..00000000
--- a/crates/frontend-daemon/src/components/config_editor/mod.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-mod auth;
-mod container;
-mod inference;
-mod letsencrypt;
-pub mod pages;
-pub mod providers;
-mod server;
-mod shared;
-mod sub_nav;
-mod tlsforward;
-pub mod types;
-
-pub use container::ConfigEditor;
diff --git a/crates/frontend-daemon/src/components/config_editor/pages/auth.rs b/crates/frontend-daemon/src/components/config_editor/pages/auth.rs
deleted file mode 100644
index f5b42c01..00000000
--- a/crates/frontend-daemon/src/components/config_editor/pages/auth.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-use super::super::{auth::AuthConfigSection, types::AuthConfig};
-use yew::prelude::*;
-
-#[derive(Properties, PartialEq)]
-pub struct AuthConfigPageProps {
-    pub config: AuthConfig,
-    pub on_change: Callback<AuthConfig>,
-}
-
-#[function_component(AuthConfigPage)]
-pub fn auth_config_page(props: &AuthConfigPageProps) -> Html {
-    html! {
-        <div class="p-6">
-            <div class="mb-6">
-                <h2 class="text-lg font-semibold text-gray-900 dark:text-gray-100">
-                    {"Authentication Settings"}
-                </h2>
-                <p class="mt-1 text-sm text-gray-600 dark:text-gray-400">
-                    {"Configure authentication methods, WebAuthn, JWT, and registration policies"}
-                </p>
-            </div>
-
-            <AuthConfigSection
-                config={props.config.clone()}
-                on_change={props.on_change.clone()}
-            />
-        </div>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/config_editor/pages/inference.rs b/crates/frontend-daemon/src/components/config_editor/pages/inference.rs
deleted file mode 100644
index ffa24c10..00000000
--- a/crates/frontend-daemon/src/components/config_editor/pages/inference.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-use super::super::{inference::InferenceConfigSection, types::LocalInferenceConfig};
-use yew::prelude::*;
-
-#[derive(Properties, PartialEq)]
-pub struct InferenceConfigPageProps {
-    pub config: Option<LocalInferenceConfig>,
-    pub on_change: Callback<Option<LocalInferenceConfig>>,
-}
-
-#[function_component(InferenceConfigPage)]
-pub fn inference_config_page(props: &InferenceConfigPageProps) -> Html {
-    html! {
-        <div class="p-6">
-            <div class="mb-6">
-                <h2 class="text-lg font-semibold text-gray-900 dark:text-gray-100">
-                    {"Local Inference Settings"}
-                </h2>
-                <p class="mt-1 text-sm text-gray-600 dark:text-gray-400">
-                    {"Configure local AI model inference parameters and resource limits"}
-                </p>
-            </div>
-
-            <InferenceConfigSection
-                config={props.config.clone()}
-                on_change={props.on_change.clone()}
-            />
-        </div>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/config_editor/pages/mod.rs b/crates/frontend-daemon/src/components/config_editor/pages/mod.rs
deleted file mode 100644
index 2cfd0e56..00000000
--- a/crates/frontend-daemon/src/components/config_editor/pages/mod.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-mod auth;
-mod inference;
-mod network;
-mod providers;
-mod server;
-
-pub use auth::AuthConfigPage;
-pub use inference::InferenceConfigPage;
-pub use network::NetworkConfigPage;
-pub use providers::ProvidersConfigPage;
-pub use server::ServerConfigPage;
diff --git a/crates/frontend-daemon/src/components/config_editor/pages/network.rs b/crates/frontend-daemon/src/components/config_editor/pages/network.rs
deleted file mode 100644
index 7fdc12ef..00000000
--- a/crates/frontend-daemon/src/components/config_editor/pages/network.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-use super::super::{
-    letsencrypt::LetsEncryptConfigSection,
-    tlsforward::TlsForwardConfigSection,
-    types::{LetsEncryptConfig, TlsForwardConfig},
-};
-use yew::prelude::*;
-
-#[derive(Properties, PartialEq)]
-pub struct NetworkConfigPageProps {
-    pub tlsforward: TlsForwardConfig,
-    pub letsencrypt: LetsEncryptConfig,
-    pub on_tlsforward_change: Callback<TlsForwardConfig>,
-    pub on_letsencrypt_change: Callback<LetsEncryptConfig>,
-}
-
-#[function_component(NetworkConfigPage)]
-pub fn network_config_page(props: &NetworkConfigPageProps) -> Html {
-    html! {
-        <div class="p-6">
-            <div class="mb-6">
-                <h2 class="text-lg font-semibold text-gray-900 dark:text-gray-100">
-                    {"Network & Security"}
-                </h2>
-                <p class="mt-1 text-sm text-gray-600 dark:text-gray-400">
-                    {"Configure TLS forwarding, certificates, and network security settings"}
-                </p>
-            </div>
-
-            <div class="space-y-6">
-                <div>
-                    <h3 class="text-md font-medium text-gray-800 dark:text-gray-200 mb-3">
-                        {"TLS Forwarding"}
-                    </h3>
-                    <TlsForwardConfigSection
-                        config={props.tlsforward.clone()}
-                        on_change={props.on_tlsforward_change.clone()}
-                    />
-                </div>
-
-                <div>
-                    <h3 class="text-md font-medium text-gray-800 dark:text-gray-200 mb-3">
-                        {"Let's Encrypt Certificates"}
-                    </h3>
-                    <LetsEncryptConfigSection
-                        config={props.letsencrypt.clone()}
-                        on_change={props.on_letsencrypt_change.clone()}
-                    />
-                </div>
-            </div>
-        </div>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/config_editor/pages/providers.rs b/crates/frontend-daemon/src/components/config_editor/pages/providers.rs
deleted file mode 100644
index 4e9d3ade..00000000
--- a/crates/frontend-daemon/src/components/config_editor/pages/providers.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-use super::super::{providers::ProvidersConfigSection, types::ProviderConfig};
-use yew::prelude::*;
-
-#[derive(Properties, PartialEq)]
-pub struct ProvidersConfigPageProps {
-    pub providers: Vec<ProviderConfig>,
-    pub on_change: Callback<Vec<ProviderConfig>>,
-}
-
-#[function_component(ProvidersConfigPage)]
-pub fn providers_config_page(props: &ProvidersConfigPageProps) -> Html {
-    html! {
-        <div class="p-6">
-            <div class="mb-6">
-                <h2 class="text-lg font-semibold text-gray-900 dark:text-gray-100">
-                    {"AI Provider Configuration"}
-                </h2>
-                <p class="mt-1 text-sm text-gray-600 dark:text-gray-400">
-                    {"Manage AI provider connections, API keys, and model configurations"}
-                </p>
-            </div>
-
-            <ProvidersConfigSection
-                providers={props.providers.clone()}
-                on_change={props.on_change.clone()}
-            />
-        </div>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/config_editor/pages/server.rs b/crates/frontend-daemon/src/components/config_editor/pages/server.rs
deleted file mode 100644
index b82cec63..00000000
--- a/crates/frontend-daemon/src/components/config_editor/pages/server.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-use super::super::{server::ServerConfigSection, types::ServerConfig};
-use yew::prelude::*;
-
-#[derive(Properties, PartialEq)]
-pub struct ServerConfigPageProps {
-    pub config: ServerConfig,
-    pub on_change: Callback<ServerConfig>,
-}
-
-#[function_component(ServerConfigPage)]
-pub fn server_config_page(props: &ServerConfigPageProps) -> Html {
-    html! {
-        <div class="p-6">
-            <div class="mb-6">
-                <h2 class="text-lg font-semibold text-gray-900 dark:text-gray-100">
-                    {"Server Configuration"}
-                </h2>
-                <p class="mt-1 text-sm text-gray-600 dark:text-gray-400">
-                    {"Configure the server's network settings and ports"}
-                </p>
-            </div>
-
-            <ServerConfigSection
-                config={props.config.clone()}
-                on_change={props.on_change.clone()}
-            />
-        </div>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/config_editor/providers/mod.rs b/crates/frontend-daemon/src/components/config_editor/providers/mod.rs
deleted file mode 100644
index b3bbc7eb..00000000
--- a/crates/frontend-daemon/src/components/config_editor/providers/mod.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-pub mod provider_card;
-pub mod provider_config_panel;
-pub mod provider_grid;
-pub mod provider_registry;
-mod providers_section;
-
-pub use provider_grid::ProviderGrid;
-pub use providers_section::ProvidersConfigSection;
diff --git a/crates/frontend-daemon/src/components/config_editor/providers/provider_card.rs b/crates/frontend-daemon/src/components/config_editor/providers/provider_card.rs
deleted file mode 100644
index be05ee20..00000000
--- a/crates/frontend-daemon/src/components/config_editor/providers/provider_card.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-use super::provider_registry::ProviderMetadata;
-use yew::prelude::*;
-
-#[derive(Properties)]
-pub struct ProviderCardProps {
-    pub provider: &'static ProviderMetadata,
-    pub is_configured: bool,
-    pub on_click: Callback<&'static str>,
-}
-
-impl PartialEq for ProviderCardProps {
-    fn eq(&self, other: &Self) -> bool {
-        self.provider.id == other.provider.id && self.is_configured == other.is_configured
-    }
-}
-
-#[function_component(ProviderCard)]
-pub fn provider_card(props: &ProviderCardProps) -> Html {
-    let onclick = {
-        let provider_id = props.provider.id;
-        let on_click = props.on_click.clone();
-        Callback::from(move |_| {
-            on_click.emit(provider_id);
-        })
-    };
-
-    html! {
-        <button
-            class={classes!(
-                "relative", "group", "p-4", "rounded-lg", "border-2",
-                "transition-all", "duration-200", "flex", "flex-col",
-                "items-center", "justify-center", "gap-2", "cursor-pointer",
-                "hover:scale-105", "hover:shadow-lg",
-                if props.is_configured {
-                    "border-blue-500 dark:border-blue-400 bg-blue-50 dark:bg-blue-900/20"
-                } else {
-                    "border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 hover:border-gray-300 dark:hover:border-gray-600"
-                }
-            )}
-            onclick={onclick}
-            type="button"
-        >
-            // Configured indicator
-            if props.is_configured {
-                <div class="absolute top-2 right-2">
-                    <svg class="w-5 h-5 text-blue-500 dark:text-blue-400" fill="currentColor" viewBox="0 0 20 20">
-                        <path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm3.707-9.293a1 1 0 00-1.414-1.414L9 10.586 7.707 9.293a1 1 0 00-1.414 1.414l2 2a1 1 0 001.414 0l4-4z" clip-rule="evenodd"/>
-                    </svg>
-                </div>
-            }
-
-            // Provider icon
-            <div class="w-16 h-16 flex items-center justify-center">
-                <img
-                    src={props.provider.icon_path}
-                    alt={props.provider.display_name}
-                    class="w-full h-full object-contain rounded-lg"
-                />
-            </div>
-
-            // Provider name
-            <span class={classes!(
-                "text-sm", "font-medium", "text-center",
-                if props.is_configured {
-                    "text-blue-700 dark:text-blue-300"
-                } else {
-                    "text-gray-700 dark:text-gray-300"
-                }
-            )}>
-                {props.provider.display_name}
-            </span>
-
-            // Hover overlay
-            <div class="absolute inset-0 rounded-lg bg-black opacity-0 group-hover:opacity-5 transition-opacity pointer-events-none"></div>
-        </button>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/config_editor/providers/provider_config_panel.rs b/crates/frontend-daemon/src/components/config_editor/providers/provider_config_panel.rs
deleted file mode 100644
index d7a2ee1b..00000000
--- a/crates/frontend-daemon/src/components/config_editor/providers/provider_config_panel.rs
+++ /dev/null
@@ -1,294 +0,0 @@
-use super::super::{
-    shared::{ConfigField, ConfigInput},
-    types::ProviderConfig,
-};
-use super::provider_registry::ProviderMetadata;
-use web_sys::HtmlInputElement;
-use yew::prelude::*;
-
-#[derive(Properties)]
-pub struct ProviderConfigPanelProps {
-    pub provider: &'static ProviderMetadata,
-    pub config: ProviderConfig,
-    pub existing_names: Vec<String>,
-    pub on_save: Callback<ProviderConfig>,
-    pub on_delete: Callback<String>,
-    pub on_close: Callback<()>,
-}
-
-impl PartialEq for ProviderConfigPanelProps {
-    fn eq(&self, other: &Self) -> bool {
-        self.provider.id == other.provider.id
-            && self.config == other.config
-            && self.existing_names == other.existing_names
-    }
-}
-
-#[function_component(ProviderConfigPanel)]
-pub fn provider_config_panel(props: &ProviderConfigPanelProps) -> Html {
-    let config = use_state(|| props.config.clone());
-    let is_editing = props.existing_names.contains(&props.config.name);
-
-    let on_name_change = {
-        let config = config.clone();
-        Callback::from(move |value: String| {
-            let mut new_config = (*config).clone();
-            new_config.name = value;
-            config.set(new_config);
-        })
-    };
-
-    let on_base_url_change = {
-        let config = config.clone();
-        Callback::from(move |value: String| {
-            let mut new_config = (*config).clone();
-            new_config.base_url = value;
-            config.set(new_config);
-        })
-    };
-
-    let on_api_key_change = {
-        let config = config.clone();
-        Callback::from(move |value: String| {
-            let mut new_config = (*config).clone();
-            new_config.api_key = if value.is_empty() { None } else { Some(value) };
-            config.set(new_config);
-        })
-    };
-
-    let on_timeout_change = {
-        let config = config.clone();
-        Callback::from(move |value: String| {
-            if let Ok(timeout) = value.parse::<u64>() {
-                let mut new_config = (*config).clone();
-                new_config.timeout_seconds = timeout;
-                config.set(new_config);
-            }
-        })
-    };
-
-    let on_models_change = {
-        let config = config.clone();
-        Callback::from(move |e: InputEvent| {
-            let input: HtmlInputElement = e.target_unchecked_into();
-            let value = input.value();
-            let mut new_config = (*config).clone();
-            new_config.models = value
-                .split(',')
-                .map(|s| s.trim().to_string())
-                .filter(|s| !s.is_empty())
-                .collect();
-            config.set(new_config);
-        })
-    };
-
-    let on_save = {
-        let config = config.clone();
-        let on_save = props.on_save.clone();
-        let existing_names = props.existing_names.clone();
-        let original_name = props.config.name.clone();
-
-        Callback::from(move |e: MouseEvent| {
-            e.prevent_default();
-
-            let new_config = (*config).clone();
-
-            // Validate name is not empty
-            if new_config.name.is_empty() {
-                return;
-            }
-
-            // Check for duplicate names (except when editing the same config)
-            if new_config.name != original_name && existing_names.contains(&new_config.name) {
-                return;
-            }
-
-            on_save.emit(new_config);
-        })
-    };
-
-    let on_delete = {
-        let config_name = props.config.name.clone();
-        let on_delete = props.on_delete.clone();
-
-        Callback::from(move |e: MouseEvent| {
-            e.prevent_default();
-            on_delete.emit(config_name.clone());
-        })
-    };
-
-    let on_close = {
-        let on_close = props.on_close.clone();
-        Callback::from(move |_| {
-            on_close.emit(());
-        })
-    };
-
-    let on_backdrop_click = {
-        let on_close = props.on_close.clone();
-        Callback::from(move |e: MouseEvent| {
-            e.prevent_default();
-            on_close.emit(());
-        })
-    };
-
-    let on_panel_click = Callback::from(|e: MouseEvent| {
-        e.stop_propagation();
-    });
-
-    html! {
-        <div
-            class="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center p-4 z-50"
-            onclick={on_backdrop_click}
-        >
-            <div
-                class="bg-white dark:bg-gray-800 rounded-lg shadow-xl max-w-2xl w-full max-h-[90vh] overflow-y-auto"
-                onclick={on_panel_click}
-            >
-                // Header
-                <div class="border-b border-gray-200 dark:border-gray-700 px-6 py-4">
-                    <div class="flex items-center justify-between">
-                        <div class="flex items-center gap-3">
-                            <img
-                                src={props.provider.icon_path}
-                                alt={props.provider.display_name}
-                                class="w-8 h-8 object-contain"
-                            />
-                            <h2 class="text-xl font-semibold text-gray-800 dark:text-gray-200">
-                                {format!("Configure {}", props.provider.display_name)}
-                            </h2>
-                        </div>
-                        <button
-                            class="text-gray-400 hover:text-gray-600 dark:hover:text-gray-300"
-                            onclick={on_close.clone()}
-                            type="button"
-                        >
-                            <svg class="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"></path>
-                            </svg>
-                        </button>
-                    </div>
-                </div>
-
-                // Content
-                <div class="p-6 space-y-4">
-                    <ConfigField
-                        label="Configuration Name"
-                        help_text="Unique identifier for this provider configuration"
-                    >
-                        <ConfigInput
-                            value={config.name.clone()}
-                            on_change={on_name_change}
-                            placeholder="my-provider"
-                        />
-                    </ConfigField>
-
-                    <ConfigField
-                        label="Base URL"
-                        help_text="API endpoint URL"
-                    >
-                        <ConfigInput
-                            value={config.base_url.clone()}
-                            on_change={on_base_url_change}
-                            placeholder={props.provider.default_base_url}
-                        />
-                    </ConfigField>
-
-                    if props.provider.requires_api_key {
-                        <ConfigField
-                            label="API Key"
-                            help_text="Authentication key for the provider"
-                        >
-                            <ConfigInput
-                                value={config.api_key.clone().unwrap_or_default()}
-                                on_change={on_api_key_change}
-                                input_type="password"
-                                placeholder={props.provider.placeholder_api_key}
-                            />
-                        </ConfigField>
-                    }
-
-                    <ConfigField
-                        label="Timeout (seconds)"
-                        help_text="Request timeout in seconds"
-                    >
-                        <ConfigInput
-                            value={config.timeout_seconds.to_string()}
-                            on_change={on_timeout_change}
-                            input_type="number"
-                            placeholder="30"
-                        />
-                    </ConfigField>
-
-                    <ConfigField
-                        label="Supported Models"
-                        help_text="Comma-separated list of model identifiers"
-                    >
-                        <input
-                            type="text"
-                            value={config.models.join(", ")}
-                            oninput={on_models_change}
-                            placeholder={if !props.provider.supported_models.is_empty() {
-                                props.provider.supported_models.join(", ")
-                            } else {
-                                "gpt-4, gpt-3.5-turbo".to_string()
-                            }}
-                            class="w-full px-2.5 py-1.5 text-sm border border-gray-300 dark:border-gray-600 rounded-md shadow-sm
-                                   focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500
-                                   bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100"
-                        />
-                    </ConfigField>
-
-                    // Default headers info (read-only)
-                    if !props.provider.default_headers.is_empty() {
-                        <div class="p-3 bg-blue-50 dark:bg-blue-900/20 rounded-md">
-                            <p class="text-sm text-blue-700 dark:text-blue-300">
-                                {"Default headers will be automatically included:"}
-                            </p>
-                            <ul class="mt-1 text-xs text-blue-600 dark:text-blue-400">
-                                {props.provider.default_headers.iter().map(|(key, value)| {
-                                    html! {
-                                        <li>{format!("{}: {}", key, value)}</li>
-                                    }
-                                }).collect::<Html>()}
-                            </ul>
-                        </div>
-                    }
-                </div>
-
-                // Footer
-                <div class="border-t border-gray-200 dark:border-gray-700 px-6 py-4">
-                    <div class="flex justify-between">
-                        <div>
-                            if is_editing {
-                                <button
-                                    class="px-4 py-2 text-red-600 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300"
-                                    onclick={on_delete}
-                                    type="button"
-                                >
-                                    {"Delete"}
-                                </button>
-                            }
-                        </div>
-                        <div class="flex gap-3">
-                            <button
-                                class="px-4 py-2 text-gray-600 hover:text-gray-700 dark:text-gray-400 dark:hover:text-gray-300"
-                                onclick={on_close}
-                                type="button"
-                            >
-                                {"Cancel"}
-                            </button>
-                            <button
-                                class="px-4 py-2 bg-blue-500 hover:bg-blue-600 text-white rounded-md transition-colors"
-                                onclick={on_save}
-                                type="button"
-                            >
-                                {if is_editing { "Update" } else { "Add Provider" }}
-                            </button>
-                        </div>
-                    </div>
-                </div>
-            </div>
-        </div>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/config_editor/providers/provider_grid.rs b/crates/frontend-daemon/src/components/config_editor/providers/provider_grid.rs
deleted file mode 100644
index f26b951b..00000000
--- a/crates/frontend-daemon/src/components/config_editor/providers/provider_grid.rs
+++ /dev/null
@@ -1,214 +0,0 @@
-use super::super::types::ProviderConfig;
-use super::provider_card::ProviderCard;
-use super::provider_config_panel::ProviderConfigPanel;
-use super::provider_registry::{get_all_providers, ProviderMetadata};
-use yew::prelude::*;
-
-#[derive(Properties, PartialEq)]
-pub struct ProviderGridProps {
-    pub providers: Vec<ProviderConfig>,
-    pub on_change: Callback<Vec<ProviderConfig>>,
-}
-
-#[function_component(ProviderGrid)]
-pub fn provider_grid(props: &ProviderGridProps) -> Html {
-    let selected_provider = use_state(|| None::<&'static ProviderMetadata>);
-    let editing_config = use_state(|| None::<ProviderConfig>);
-
-    let all_providers = get_all_providers();
-
-    // Check if a provider is configured
-    let is_provider_configured =
-        |provider_id: &str| -> bool { props.providers.iter().any(|p| p.provider == provider_id) };
-
-    let on_provider_click = {
-        let selected_provider = selected_provider.clone();
-        let editing_config = editing_config.clone();
-        let providers = props.providers.clone();
-
-        Callback::from(move |provider_id: &'static str| {
-            if let Some(provider_meta) = get_all_providers().iter().find(|p| p.id == provider_id) {
-                selected_provider.set(Some(*provider_meta));
-
-                // If provider is already configured, load its config for editing
-                let config = providers
-                    .iter()
-                    .find(|p| p.provider == provider_id)
-                    .cloned()
-                    .unwrap_or_else(|| {
-                        // Create new config with defaults
-                        let name = if provider_id == "custom" {
-                            format!("custom-{}", providers.len() + 1)
-                        } else {
-                            provider_id.to_string()
-                        };
-                        provider_meta.to_default_config(name)
-                    });
-
-                editing_config.set(Some(config));
-            }
-        })
-    };
-
-    let on_config_save = {
-        let selected_provider = selected_provider.clone();
-        let editing_config = editing_config.clone();
-        let providers = props.providers.clone();
-        let on_change = props.on_change.clone();
-
-        Callback::from(move |new_config: ProviderConfig| {
-            let mut updated_providers = providers.clone();
-
-            // Find if this provider already exists
-            if let Some(index) = updated_providers
-                .iter()
-                .position(|p| p.provider == new_config.provider && p.name == new_config.name)
-            {
-                // Update existing
-                updated_providers[index] = new_config;
-            } else if let Some(index) = updated_providers
-                .iter()
-                .position(|p| p.name == new_config.name)
-            {
-                // Update by name (in case provider type changed)
-                updated_providers[index] = new_config;
-            } else {
-                // Add new
-                updated_providers.push(new_config);
-            }
-
-            on_change.emit(updated_providers);
-            selected_provider.set(None);
-            editing_config.set(None);
-        })
-    };
-
-    let on_config_delete = {
-        let selected_provider = selected_provider.clone();
-        let editing_config = editing_config.clone();
-        let providers = props.providers.clone();
-        let on_change = props.on_change.clone();
-
-        Callback::from(move |config_name: String| {
-            let updated_providers = providers
-                .iter()
-                .filter(|p| p.name != config_name)
-                .cloned()
-                .collect();
-
-            on_change.emit(updated_providers);
-            selected_provider.set(None);
-            editing_config.set(None);
-        })
-    };
-
-    let on_close = {
-        let selected_provider = selected_provider.clone();
-        let editing_config = editing_config.clone();
-
-        Callback::from(move |_| {
-            selected_provider.set(None);
-            editing_config.set(None);
-        })
-    };
-
-    html! {
-        <div>
-            // Configured providers section
-            if !props.providers.is_empty() {
-                <div class="mb-6">
-                    <h3 class="text-sm font-medium text-gray-700 dark:text-gray-300 mb-3">
-                        {"Configured Providers"}
-                    </h3>
-                    <div class="space-y-2">
-                        {props.providers.iter().map(|config| {
-                            let on_edit = {
-                                let config = config.clone();
-                                let selected_provider = selected_provider.clone();
-                                let editing_config = editing_config.clone();
-                                Callback::from(move |_| {
-                                    if let Some(provider_meta) = get_all_providers().iter().find(|p| p.id == config.provider) {
-                                        selected_provider.set(Some(*provider_meta));
-                                        editing_config.set(Some(config.clone()));
-                                    }
-                                })
-                            };
-
-                            let on_delete = {
-                                let name = config.name.clone();
-                                let on_change = props.on_change.clone();
-                                let providers = props.providers.clone();
-                                Callback::from(move |_| {
-                                    let updated = providers.iter()
-                                        .filter(|p| p.name != name)
-                                        .cloned()
-                                        .collect();
-                                    on_change.emit(updated);
-                                })
-                            };
-
-                            html! {
-                                <div class="flex items-center justify-between p-3 bg-gray-50 dark:bg-gray-800 rounded-lg">
-                                    <div class="flex items-center gap-3">
-                                        <span class="text-sm font-medium text-gray-700 dark:text-gray-300">
-                                            {&config.name}
-                                        </span>
-                                        <span class="text-xs text-gray-500 dark:text-gray-400">
-                                            {format!("({})", config.provider)}
-                                        </span>
-                                    </div>
-                                    <div class="flex items-center gap-2">
-                                        <button
-                                            class="text-blue-500 hover:text-blue-600 text-sm"
-                                            onclick={on_edit}
-                                            type="button"
-                                        >
-                                            {"Edit"}
-                                        </button>
-                                        <button
-                                            class="text-red-500 hover:text-red-600 text-sm"
-                                            onclick={on_delete}
-                                            type="button"
-                                        >
-                                            {"Remove"}
-                                        </button>
-                                    </div>
-                                </div>
-                            }
-                        }).collect::<Html>()}
-                    </div>
-                </div>
-            }
-
-            // Add new provider section
-            <div>
-                <h3 class="text-sm font-medium text-gray-700 dark:text-gray-300 mb-3">
-                    {"Add Provider"}
-                </h3>
-                <div class="grid grid-cols-2 sm:grid-cols-3 md:grid-cols-4 gap-4">
-                    {all_providers.iter().map(|provider| {
-                        html! {
-                            <ProviderCard
-                                provider={provider}
-                                is_configured={is_provider_configured(provider.id)}
-                                on_click={on_provider_click.clone()}
-                            />
-                        }
-                    }).collect::<Html>()}
-                </div>
-            </div>
-
-            // Configuration panel modal
-            if let (Some(provider), Some(config)) = (*selected_provider, (*editing_config).clone()) {
-                <ProviderConfigPanel
-                    provider={provider}
-                    config={config}
-                    existing_names={props.providers.iter().map(|p| p.name.clone()).collect::<Vec<String>>()}
-                    on_save={on_config_save}
-                    on_delete={on_config_delete}
-                    on_close={on_close}
-                />
-            }
-        </div>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/config_editor/providers/provider_registry.rs b/crates/frontend-daemon/src/components/config_editor/providers/provider_registry.rs
deleted file mode 100644
index be15cc1d..00000000
--- a/crates/frontend-daemon/src/components/config_editor/providers/provider_registry.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-use std::collections::HashMap;
-use std::sync::LazyLock;
-
-#[derive(Debug, Clone)]
-pub struct ProviderMetadata {
-    pub id: &'static str,
-    pub display_name: &'static str,
-    pub icon_path: &'static str,
-    pub default_base_url: &'static str,
-    pub requires_api_key: bool,
-    pub supported_models: Vec<&'static str>,
-    pub default_headers: Vec<(&'static str, &'static str)>,
-    pub placeholder_api_key: &'static str,
-}
-
-pub static PROVIDER_REGISTRY: LazyLock<HashMap<&'static str, ProviderMetadata>> =
-    LazyLock::new(|| {
-        let providers = vec![
-            ProviderMetadata {
-                id: "openai",
-                display_name: "OpenAI",
-                icon_path: "/assets/providers/openai.svg",
-                default_base_url: "https://api.openai.com",
-                requires_api_key: true,
-                supported_models: vec![
-                    "gpt-4",
-                    "gpt-4-turbo",
-                    "gpt-3.5-turbo",
-                    "text-embedding-ada-002",
-                ],
-                default_headers: vec![],
-                placeholder_api_key: "sk-...",
-            },
-            ProviderMetadata {
-                id: "anthropic",
-                display_name: "Anthropic",
-                icon_path: "/assets/providers/anthropic.svg",
-                default_base_url: "https://api.anthropic.com",
-                requires_api_key: true,
-                supported_models: vec![
-                    "claude-3-opus-20240229",
-                    "claude-3-sonnet-20240229",
-                    "claude-3-haiku-20240307",
-                    "claude-2.1",
-                ],
-                default_headers: vec![("anthropic-version", "2023-06-01")],
-                placeholder_api_key: "sk-ant-...",
-            },
-            ProviderMetadata {
-                id: "groq",
-                display_name: "Groq",
-                icon_path: "/assets/providers/groq.svg",
-                default_base_url: "https://api.groq.com/openai",
-                requires_api_key: true,
-                supported_models: vec!["llama2-70b-4096", "mixtral-8x7b-32768", "gemma-7b-it"],
-                default_headers: vec![],
-                placeholder_api_key: "gsk_...",
-            },
-            ProviderMetadata {
-                id: "mistral",
-                display_name: "Mistral AI",
-                icon_path: "/assets/providers/mistral.svg",
-                default_base_url: "https://api.mistral.ai",
-                requires_api_key: true,
-                supported_models: vec![
-                    "mistral-large-latest",
-                    "mistral-medium-latest",
-                    "mistral-small-latest",
-                    "mistral-embed",
-                ],
-                default_headers: vec![],
-                placeholder_api_key: "...",
-            },
-            ProviderMetadata {
-                id: "gemini",
-                display_name: "Google Gemini",
-                icon_path: "/assets/providers/gemini.svg",
-                default_base_url: "https://generativelanguage.googleapis.com",
-                requires_api_key: true,
-                supported_models: vec!["gemini-pro", "gemini-pro-vision"],
-                default_headers: vec![],
-                placeholder_api_key: "AIza...",
-            },
-            ProviderMetadata {
-                id: "cohere",
-                display_name: "Cohere",
-                icon_path: "/assets/providers/cohere.svg",
-                default_base_url: "https://api.cohere.ai",
-                requires_api_key: true,
-                supported_models: vec![
-                    "command",
-                    "command-nightly",
-                    "command-light",
-                    "embed-english-v3.0",
-                ],
-                default_headers: vec![],
-                placeholder_api_key: "...",
-            },
-            ProviderMetadata {
-                id: "perplexity",
-                display_name: "Perplexity",
-                icon_path: "/assets/providers/perplexity.svg",
-                default_base_url: "https://api.perplexity.ai",
-                requires_api_key: true,
-                supported_models: vec![
-                    "pplx-7b-online",
-                    "pplx-70b-online",
-                    "codellama-34b-instruct",
-                ],
-                default_headers: vec![],
-                placeholder_api_key: "pplx-...",
-            },
-            ProviderMetadata {
-                id: "custom",
-                display_name: "Custom Provider",
-                icon_path: "/assets/providers/custom.svg",
-                default_base_url: "https://api.example.com",
-                requires_api_key: false,
-                supported_models: vec![],
-                default_headers: vec![],
-                placeholder_api_key: "your-api-key",
-            },
-        ];
-
-        providers.into_iter().map(|p| (p.id, p)).collect()
-    });
-
-pub fn get_all_providers() -> Vec<&'static ProviderMetadata> {
-    let mut providers: Vec<_> = PROVIDER_REGISTRY.values().collect();
-    // Sort by display name, but keep "Custom" at the end
-    providers.sort_by(|a, b| {
-        if a.id == "custom" {
-            std::cmp::Ordering::Greater
-        } else if b.id == "custom" {
-            std::cmp::Ordering::Less
-        } else {
-            a.display_name.cmp(b.display_name)
-        }
-    });
-    providers
-}
-
-impl ProviderMetadata {
-    pub fn to_default_config(&self, name: String) -> super::super::types::ProviderConfig {
-        super::super::types::ProviderConfig {
-            name,
-            provider: self.id.to_string(),
-            base_url: self.default_base_url.to_string(),
-            api_key: None,
-            timeout_seconds: 30,
-            models: self
-                .supported_models
-                .iter()
-                .map(|s| s.to_string())
-                .collect(),
-        }
-    }
-}
diff --git a/crates/frontend-daemon/src/components/config_editor/providers/providers_section.rs b/crates/frontend-daemon/src/components/config_editor/providers/providers_section.rs
deleted file mode 100644
index b52256dc..00000000
--- a/crates/frontend-daemon/src/components/config_editor/providers/providers_section.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-use yew::prelude::*;
-
-use super::super::shared::ConfigSection;
-use super::super::types::ProviderConfig;
-use super::ProviderGrid;
-
-#[derive(Properties, PartialEq)]
-pub struct ProvidersConfigSectionProps {
-    pub providers: Vec<ProviderConfig>,
-    pub on_change: Callback<Vec<ProviderConfig>>,
-}
-
-#[function_component(ProvidersConfigSection)]
-pub fn providers_config_section(props: &ProvidersConfigSectionProps) -> Html {
-    html! {
-        <ConfigSection title="AI Providers">
-            <ProviderGrid
-                providers={props.providers.clone()}
-                on_change={props.on_change.clone()}
-            />
-        </ConfigSection>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/config_editor/server.rs b/crates/frontend-daemon/src/components/config_editor/server.rs
deleted file mode 100644
index bf6f3369..00000000
--- a/crates/frontend-daemon/src/components/config_editor/server.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-use yew::prelude::*;
-
-use super::shared::{ConfigField, ConfigInput, ConfigSection, ConfigToggle};
-use super::types::ServerConfig;
-
-#[derive(Properties, PartialEq)]
-pub struct ServerConfigSectionProps {
-    pub config: ServerConfig,
-    pub on_change: Callback<ServerConfig>,
-}
-
-#[function_component(ServerConfigSection)]
-pub fn server_config_section(props: &ServerConfigSectionProps) -> Html {
-    let config = props.config.clone();
-
-    let on_host_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            let mut new_config = config.clone();
-            new_config.host = value;
-            on_change.emit(new_config);
-        })
-    };
-
-    let on_port_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            if let Ok(port) = value.parse::<u16>() {
-                let mut new_config = config.clone();
-                new_config.port = port;
-                on_change.emit(new_config);
-            }
-        })
-    };
-
-    let on_metrics_port_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            let mut new_config = config.clone();
-            new_config.metrics_port = if value.is_empty() {
-                None
-            } else {
-                value.parse::<u16>().ok()
-            };
-            on_change.emit(new_config);
-        })
-    };
-
-    let is_host_loopback = {
-        let host = props.config.host.to_lowercase();
-        host == "127.0.0.1" || host == "localhost" || host == "::1"
-    };
-
-    let on_allow_local_bypass_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: bool| {
-            let mut new_config = config.clone();
-            new_config.allow_local_bypass = value;
-            on_change.emit(new_config);
-        })
-    };
-
-    html! {
-        <ConfigSection title="Server Configuration">
-            <ConfigField
-                label="Host"
-                help_text="IP address to bind the server to"
-            >
-                <ConfigInput
-                    value={props.config.host.clone()}
-                    on_change={on_host_change}
-                    placeholder="127.0.0.1"
-                />
-            </ConfigField>
-
-            <ConfigField
-                label="Port"
-                help_text="Port number for the main server"
-            >
-                <ConfigInput
-                    value={props.config.port.to_string()}
-                    on_change={on_port_change}
-                    input_type="number"
-                    placeholder="31145"
-                />
-            </ConfigField>
-
-            <ConfigField
-                label="Metrics Port"
-                help_text="Port for Prometheus metrics endpoint (optional)"
-            >
-                <ConfigInput
-                    value={props.config.metrics_port.map_or(String::new(), |p| p.to_string())}
-                    on_change={on_metrics_port_change}
-                    input_type="number"
-                    placeholder="9090"
-                />
-            </ConfigField>
-
-            <ConfigToggle
-                label="Allow Localhost Bypass"
-                checked={props.config.allow_local_bypass && is_host_loopback}
-                on_change={on_allow_local_bypass_change}
-                disabled={!is_host_loopback}
-                help_text={Some(if is_host_loopback {
-                    "Allow requests from 127.0.0.1/localhost to skip auth"
-                } else {
-                    "Enable only when server host is localhost/127.0.0.1/::1"
-                }.to_string())}
-            />
-        </ConfigSection>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/config_editor/shared.rs b/crates/frontend-daemon/src/components/config_editor/shared.rs
deleted file mode 100644
index 3045ca6b..00000000
--- a/crates/frontend-daemon/src/components/config_editor/shared.rs
+++ /dev/null
@@ -1,336 +0,0 @@
-use yew::prelude::*;
-
-#[derive(Properties, PartialEq)]
-pub struct ConfigSectionProps {
-    pub title: String,
-    pub children: Html,
-    #[prop_or_default]
-    pub enabled: Option<bool>,
-    #[prop_or_default]
-    pub on_toggle: Option<Callback<bool>>,
-}
-
-#[function_component(ConfigSection)]
-pub fn config_section(props: &ConfigSectionProps) -> Html {
-    let is_enabled = props.enabled.unwrap_or(true);
-    let expanded = use_state(|| is_enabled);
-
-    // Auto-collapse when disabled, auto-expand when enabled
-    {
-        let expanded = expanded.clone();
-        use_effect_with(is_enabled, move |enabled| {
-            expanded.set(*enabled);
-            || ()
-        });
-    }
-
-    let toggle_expanded = {
-        let expanded = expanded.clone();
-        Callback::from(move |e: MouseEvent| {
-            e.prevent_default();
-            expanded.set(!*expanded);
-        })
-    };
-
-    let on_toggle_enabled = {
-        let on_toggle = props.on_toggle.clone();
-        Callback::from(move |e: MouseEvent| {
-            e.stop_propagation();
-            if let Some(callback) = &on_toggle {
-                callback.emit(!is_enabled);
-            }
-        })
-    };
-
-    html! {
-        <div class={classes!(
-            "border", "rounded-lg", "mb-3", "transition-all", "duration-300",
-            if is_enabled {
-                "border-gray-200 dark:border-gray-700"
-            } else {
-                "border-gray-200/50 dark:border-gray-700/50 opacity-60"
-            }
-        )}>
-            <div
-                class={classes!(
-                    "px-4", "py-2.5", "flex", "items-center", "justify-between", "transition-colors", "cursor-pointer",
-                    if is_enabled {
-                        "hover:bg-gray-50 dark:hover:bg-gray-800"
-                    } else {
-                        "bg-gray-50/50 dark:bg-gray-800/50"
-                    }
-                )}
-                onclick={toggle_expanded.clone()}
-            >
-                <h3 class={classes!(
-                    "text-base", "font-medium",
-                    if is_enabled {
-                        "text-gray-900 dark:text-gray-100"
-                    } else {
-                        "text-gray-500 dark:text-gray-400"
-                    }
-                )}>
-                    {&props.title}
-                </h3>
-                <div class="flex items-center gap-3">
-                    {if props.on_toggle.is_some() {
-                        html! {
-                            <div class="flex items-center gap-2">
-                                <span class="text-sm text-gray-600 dark:text-gray-400">{"Enable"}</span>
-                                <button
-                                    type="button"
-                                    role="switch"
-                                    aria-checked={is_enabled.to_string()}
-                                    onclick={on_toggle_enabled}
-                                    class={classes!(
-                                        "relative", "inline-flex", "h-5", "w-9", "items-center", "rounded-full",
-                                        "transition-colors", "focus:outline-none", "focus:ring-2",
-                                        "focus:ring-blue-500", "focus:ring-offset-1",
-                                        if is_enabled {
-                                            "bg-blue-600"
-                                        } else {
-                                            "bg-gray-300 dark:bg-gray-600"
-                                        }
-                                    )}
-                                >
-                                    <span
-                                        class={classes!(
-                                            "inline-block", "h-3.5", "w-3.5", "rounded-full", "bg-white",
-                                            "transition-transform", "duration-200",
-                                            if is_enabled {
-                                                "translate-x-5"
-                                            } else {
-                                                "translate-x-1"
-                                            }
-                                        )}
-                                    />
-                                </button>
-                            </div>
-                        }
-                    } else {
-                        html! {
-                            <svg
-                                class={classes!(
-                                    "w-4", "h-4", "text-gray-500", "transition-transform", "duration-200",
-                                    if *expanded { "rotate-180" } else { "" }
-                                )}
-                                fill="none"
-                                stroke="currentColor"
-                                viewBox="0 0 24 24"
-                            >
-                                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7" />
-                            </svg>
-                        }
-                    }}
-                </div>
-            </div>
-            <div
-                class={classes!(
-                    "overflow-hidden", "transition-all", "duration-300",
-                    if *expanded {
-                        "max-h-[2000px] opacity-100"
-                    } else {
-                        "max-h-0 opacity-0"
-                    }
-                )}
-            >
-                <div class={classes!(
-                    "px-4", "py-3", "border-t",
-                    if is_enabled {
-                        "border-gray-200 dark:border-gray-700"
-                    } else {
-                        "border-gray-200/50 dark:border-gray-700/50 pointer-events-none"
-                    }
-                )}>
-                    {props.children.clone()}
-                </div>
-            </div>
-        </div>
-    }
-}
-
-#[derive(Properties, PartialEq)]
-pub struct ConfigFieldProps {
-    pub label: String,
-    pub children: Html,
-    #[prop_or_default]
-    pub help_text: Option<String>,
-    #[prop_or(false)]
-    pub full_width: bool,
-}
-
-#[function_component(ConfigField)]
-pub fn config_field(props: &ConfigFieldProps) -> Html {
-    if props.full_width {
-        html! {
-            <div class="mb-3">
-                <label class="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-1">
-                    {&props.label}
-                </label>
-                {props.children.clone()}
-                if let Some(help) = &props.help_text {
-                    <p class="mt-1 text-xs text-gray-500 dark:text-gray-400">{help}</p>
-                }
-            </div>
-        }
-    } else {
-        html! {
-            <div class="mb-3 sm:flex sm:items-start sm:gap-4">
-                <label class="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-1 sm:mb-0 sm:w-1/3 sm:pt-2">
-                    {&props.label}
-                    if let Some(help) = &props.help_text {
-                        <p class="text-xs text-gray-500 dark:text-gray-400 font-normal mt-0.5">{help}</p>
-                    }
-                </label>
-                <div class="sm:flex-1">
-                    {props.children.clone()}
-                </div>
-            </div>
-        }
-    }
-}
-
-#[derive(Properties, PartialEq)]
-pub struct ConfigToggleProps {
-    pub label: String,
-    pub checked: bool,
-    pub on_change: Callback<bool>,
-    #[prop_or_default]
-    pub help_text: Option<String>,
-    #[prop_or(false)]
-    pub disabled: bool,
-}
-
-#[function_component(ConfigToggle)]
-pub fn config_toggle(props: &ConfigToggleProps) -> Html {
-    let onclick = {
-        let on_change = props.on_change.clone();
-        let checked = props.checked;
-        let disabled = props.disabled;
-        Callback::from(move |_| {
-            if !disabled {
-                on_change.emit(!checked)
-            }
-        })
-    };
-
-    html! {
-        <div class="mb-3 sm:flex sm:items-start sm:gap-4">
-            <label class="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-1 sm:mb-0 sm:w-1/3 sm:pt-2">
-                {&props.label}
-                if let Some(help) = &props.help_text {
-                    <p class="text-xs text-gray-500 dark:text-gray-400 font-normal mt-0.5">{help}</p>
-                }
-            </label>
-            <div class="sm:flex-1">
-                <button
-                    type="button"
-                    role="switch"
-                    aria-checked={props.checked.to_string()}
-                    onclick={onclick}
-                    disabled={props.disabled}
-                    class={classes!(
-                        "relative", "inline-flex", "h-6", "w-11", "items-center", "rounded-full",
-                        "transition-colors", "focus:outline-none", "focus:ring-2",
-                        "focus:ring-blue-500", "focus:ring-offset-2",
-                        if props.checked {
-                            "bg-blue-600"
-                        } else {
-                            "bg-gray-200 dark:bg-gray-700"
-                        },
-                        if props.disabled { "opacity-50 cursor-not-allowed" } else { "" }
-                    )}
-                >
-                    <span
-                        class={classes!(
-                            "inline-block", "h-4", "w-4", "rounded-full", "bg-white",
-                            "transition-transform",
-                            if props.checked {
-                                "translate-x-6"
-                            } else {
-                                "translate-x-1"
-                            }
-                        )}
-                    />
-                </button>
-            </div>
-        </div>
-    }
-}
-
-#[derive(Properties, PartialEq)]
-pub struct ConfigInputProps {
-    pub value: String,
-    pub on_change: Callback<String>,
-    #[prop_or("text".to_string())]
-    pub input_type: String,
-    #[prop_or_default]
-    pub placeholder: Option<String>,
-    #[prop_or(false)]
-    pub disabled: bool,
-}
-
-#[function_component(ConfigInput)]
-pub fn config_input(props: &ConfigInputProps) -> Html {
-    let oninput = {
-        let on_change = props.on_change.clone();
-        Callback::from(move |e: InputEvent| {
-            let input: web_sys::HtmlInputElement = e.target_unchecked_into();
-            on_change.emit(input.value());
-        })
-    };
-
-    html! {
-        <input
-            type={props.input_type.clone()}
-            value={props.value.clone()}
-            oninput={oninput}
-            placeholder={props.placeholder.clone().unwrap_or_default()}
-            disabled={props.disabled}
-            class="w-full px-2.5 py-1.5 text-sm border border-gray-300 dark:border-gray-600 rounded-md shadow-sm
-                   focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500
-                   bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100
-                   disabled:bg-gray-100 dark:disabled:bg-gray-900 disabled:cursor-not-allowed"
-        />
-    }
-}
-
-#[derive(Properties, PartialEq)]
-pub struct ConfigSelectProps {
-    pub value: String,
-    pub options: Vec<(String, String)>,
-    pub on_change: Callback<String>,
-    #[prop_or(false)]
-    pub disabled: bool,
-}
-
-#[function_component(ConfigSelect)]
-pub fn config_select(props: &ConfigSelectProps) -> Html {
-    let onchange = {
-        let on_change = props.on_change.clone();
-        Callback::from(move |e: Event| {
-            let select: web_sys::HtmlSelectElement = e.target_unchecked_into();
-            on_change.emit(select.value());
-        })
-    };
-
-    html! {
-        <select
-            value={props.value.clone()}
-            onchange={onchange}
-            disabled={props.disabled}
-            class="w-full px-2.5 py-1.5 text-sm border border-gray-300 dark:border-gray-600 rounded-md shadow-sm
-                   focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500
-                   bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100
-                   disabled:bg-gray-100 dark:disabled:bg-gray-900 disabled:cursor-not-allowed"
-        >
-            {props.options.iter().map(|(value, label)| {
-                html! {
-                    <option value={value.clone()} selected={value == &props.value}>
-                        {label}
-                    </option>
-                }
-            }).collect::<Html>()}
-        </select>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/config_editor/sub_nav.rs b/crates/frontend-daemon/src/components/config_editor/sub_nav.rs
deleted file mode 100644
index 59c48fd9..00000000
--- a/crates/frontend-daemon/src/components/config_editor/sub_nav.rs
+++ /dev/null
@@ -1,145 +0,0 @@
-use yew::prelude::*;
-
-#[derive(Clone, Copy, PartialEq)]
-pub enum ConfigPage {
-    Server,
-    Authentication,
-    Providers,
-    Network,
-    Inference,
-}
-
-impl ConfigPage {
-    pub fn label(&self) -> &'static str {
-        match self {
-            ConfigPage::Server => "Server",
-            ConfigPage::Authentication => "Authentication",
-            ConfigPage::Providers => "Providers",
-            ConfigPage::Network => "Network",
-            ConfigPage::Inference => "Inference",
-        }
-    }
-
-    pub fn icon(&self) -> Html {
-        match self {
-            ConfigPage::Server => html! {
-                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 12h14M5 12a2 2 0 01-2-2V6a2 2 0 012-2h14a2 2 0 012 2v4a2 2 0 01-2 2M5 12a2 2 0 00-2 2v4a2 2 0 002 2h14a2 2 0 002-2v-4a2 2 0 00-2-2m-2-4h.01M17 16h.01"></path>
-                </svg>
-            },
-            ConfigPage::Authentication => html! {
-                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 15v2m-6 4h12a2 2 0 002-2v-6a2 2 0 00-2-2H6a2 2 0 00-2 2v6a2 2 0 002 2zm10-10V7a4 4 0 00-8 0v4h8z"></path>
-                </svg>
-            },
-            ConfigPage::Providers => html! {
-                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 10V3L4 14h7v7l9-11h-7z"></path>
-                </svg>
-            },
-            ConfigPage::Network => html! {
-                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M21 12a9 9 0 01-9 9m9-9a9 9 0 00-9-9m9 9H3m9 9a9 9 0 01-9-9m9 9c1.657 0 3-4.03 3-9s-1.343-9-3-9m0 18c-1.657 0-3-4.03-3-9s1.343-9 3-9m-9 9a9 9 0 019-9"></path>
-                </svg>
-            },
-            ConfigPage::Inference => html! {
-                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9.75 17L9 20l-1 1h8l-1-1-.75-3M3 13h18M5 17h14a2 2 0 002-2V5a2 2 0 00-2-2H5a2 2 0 00-2 2v10a2 2 0 002 2z"></path>
-                </svg>
-            },
-        }
-    }
-
-    pub fn description(&self) -> &'static str {
-        match self {
-            ConfigPage::Server => "Configure server host, port, and metrics settings",
-            ConfigPage::Authentication => "Manage authentication, WebAuthn, and JWT settings",
-            ConfigPage::Providers => "Configure AI provider connections and API keys",
-            ConfigPage::Network => "Setup TLS forwarding and Let's Encrypt certificates",
-            ConfigPage::Inference => "Configure local inference settings and parameters",
-        }
-    }
-}
-
-#[derive(Properties, PartialEq)]
-pub struct SubNavProps {
-    pub active_page: ConfigPage,
-    pub on_change: Callback<ConfigPage>,
-}
-
-#[function_component(SubNav)]
-pub fn sub_nav(props: &SubNavProps) -> Html {
-    let pages = [
-        ConfigPage::Server,
-        ConfigPage::Authentication,
-        ConfigPage::Providers,
-        ConfigPage::Network,
-        ConfigPage::Inference,
-    ];
-
-    html! {
-        <div class="border-b border-gray-200 dark:border-gray-700">
-            // Tab-style navigation
-            <div class="flex gap-1 px-4">
-                {pages.iter().map(|page| {
-                    let is_active = *page == props.active_page;
-                    let onclick = {
-                        let page = *page;
-                        let on_change = props.on_change.clone();
-                        Callback::from(move |_| on_change.emit(page))
-                    };
-
-                    html! {
-                        <button
-                            class={classes!(
-                                "px-4", "py-3", "flex", "items-center", "gap-2",
-                                "text-sm", "font-medium", "border-b-2", "transition-colors",
-                                "-mb-px", // Overlap the container border
-                                if is_active {
-                                    "text-blue-600 dark:text-blue-400 border-blue-600 dark:border-blue-400"
-                                } else {
-                                    "text-gray-600 dark:text-gray-400 border-transparent hover:text-gray-900 dark:hover:text-gray-100"
-                                }
-                            )}
-                            onclick={onclick}
-                            title={page.description()}
-                        >
-                            {page.icon()}
-                            <span>{page.label()}</span>
-                        </button>
-                    }
-                }).collect::<Html>()}
-            </div>
-
-            // Alternative: Pill-style navigation (commented out)
-            // <div class="flex gap-2 px-4 py-3">
-            //     {pages.iter().map(|page| {
-            //         let is_active = *page == props.active_page;
-            //         let onclick = {
-            //             let page = *page;
-            //             let on_change = props.on_change.clone();
-            //             Callback::from(move |_| on_change.emit(page))
-            //         };
-            //
-            //         html! {
-            //             <button
-            //                 class={classes!(
-            //                     "px-4", "py-2", "flex", "items-center", "gap-2",
-            //                     "text-sm", "font-medium", "rounded-lg", "transition-colors",
-            //                     if is_active {
-            //                         "bg-blue-100 dark:bg-blue-900 text-blue-700 dark:text-blue-300"
-            //                     } else {
-            //                         "text-gray-600 dark:text-gray-400 hover:bg-gray-100 dark:hover:bg-gray-800"
-            //                     }
-            //                 )}
-            //                 onclick={onclick}
-            //             >
-            //                 {page.icon()}
-            //                 <span>{page.label()}</span>
-            //             </button>
-            //         }
-            //     }).collect::<Html>()}
-            // </div>
-        </div>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/config_editor/tlsforward.rs b/crates/frontend-daemon/src/components/config_editor/tlsforward.rs
deleted file mode 100644
index 6bf678cc..00000000
--- a/crates/frontend-daemon/src/components/config_editor/tlsforward.rs
+++ /dev/null
@@ -1,134 +0,0 @@
-use yew::prelude::*;
-
-use super::shared::{ConfigField, ConfigInput, ConfigSection};
-use super::types::TlsForwardConfig;
-
-#[derive(Properties, PartialEq)]
-pub struct TlsForwardConfigSectionProps {
-    pub config: TlsForwardConfig,
-    pub on_change: Callback<TlsForwardConfig>,
-}
-
-#[function_component(TlsForwardConfigSection)]
-pub fn tlsforward_config_section(props: &TlsForwardConfigSectionProps) -> Html {
-    let config = props.config.clone();
-
-    let on_enabled_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: bool| {
-            let mut new_config = config.clone();
-            new_config.enabled = value;
-            on_change.emit(new_config);
-        })
-    };
-
-    let on_addresses_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            let mut new_config = config.clone();
-            new_config.tlsforward_addresses = value
-                .lines()
-                .map(|s| s.trim().to_string())
-                .filter(|s| !s.is_empty())
-                .collect();
-            on_change.emit(new_config);
-        })
-    };
-
-    let on_max_connections_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            if let Ok(max_conn) = value.parse::<usize>() {
-                let mut new_config = config.clone();
-                new_config.max_connections = max_conn;
-                on_change.emit(new_config);
-            }
-        })
-    };
-
-    let on_secret_key_path_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            let mut new_config = config.clone();
-            new_config.secret_key_path = if value.is_empty() { None } else { Some(value) };
-            on_change.emit(new_config);
-        })
-    };
-
-    let on_heartbeat_interval_change = {
-        let config = config.clone();
-        let on_change = props.on_change.clone();
-        Callback::from(move |value: String| {
-            if let Ok(interval) = value.parse::<u64>() {
-                let mut new_config = config.clone();
-                new_config.heartbeat_interval = interval;
-                on_change.emit(new_config);
-            }
-        })
-    };
-
-    html! {
-        <ConfigSection
-            title="TLS Forward Configuration"
-            enabled={props.config.enabled}
-            on_toggle={on_enabled_change}
-        >
-            <ConfigField
-                label="TLS Forward Server Addresses"
-                help_text="Node addresses in format: node_id@host:port (one per line)"
-            >
-                <textarea
-                    class="w-full px-2.5 py-1.5 text-sm border border-gray-300 dark:border-gray-600 rounded-md shadow-sm
-                           focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500
-                           bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100 font-mono"
-                    rows="2"
-                    value={props.config.tlsforward_addresses.join("\n")}
-                    oninput={Callback::from(move |e: InputEvent| {
-                        let input: web_sys::HtmlTextAreaElement = e.target_unchecked_into();
-                        on_addresses_change.emit(input.value());
-                    })}
-                    placeholder="3dbefb2e3d56c7e32586d9a82167a8a5151f3e0f4b40b7c3d145b9060dde2f14@213.239.212.173:31145"
-                />
-            </ConfigField>
-
-            <ConfigField
-                label="Maximum Connections"
-                help_text="Maximum number of concurrent TLS connections"
-            >
-                <ConfigInput
-                    value={props.config.max_connections.to_string()}
-                    on_change={on_max_connections_change}
-                    input_type="number"
-                    placeholder="1000"
-                />
-            </ConfigField>
-
-            <ConfigField
-                label="Secret Key Path"
-                help_text="Path to store the secret key for persistent node ID (optional)"
-            >
-                <ConfigInput
-                    value={props.config.secret_key_path.clone().unwrap_or_default()}
-                    on_change={on_secret_key_path_change}
-                    placeholder="/path/to/secret.key"
-                />
-            </ConfigField>
-
-            <ConfigField
-                label="Heartbeat Interval (seconds)"
-                help_text="Interval for sending keepalive messages"
-            >
-                <ConfigInput
-                    value={props.config.heartbeat_interval.to_string()}
-                    on_change={on_heartbeat_interval_change}
-                    input_type="number"
-                    placeholder="30"
-                />
-            </ConfigField>
-        </ConfigSection>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/config_editor/types.rs b/crates/frontend-daemon/src/components/config_editor/types.rs
deleted file mode 100644
index 9156d8b8..00000000
--- a/crates/frontend-daemon/src/components/config_editor/types.rs
+++ /dev/null
@@ -1,259 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
-pub struct GateConfig {
-    #[serde(default)]
-    pub server: ServerConfig,
-    #[serde(default)]
-    pub auth: AuthConfig,
-    #[serde(default)]
-    pub providers: Vec<ProviderConfig>,
-    #[serde(default)]
-    pub tlsforward: TlsForwardConfig,
-    #[serde(default)]
-    pub letsencrypt: LetsEncryptConfig,
-    #[serde(default)]
-    pub local_inference: Option<LocalInferenceConfig>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct ServerConfig {
-    #[serde(default = "default_host")]
-    pub host: String,
-    #[serde(default = "default_port")]
-    pub port: u16,
-    #[serde(default)]
-    pub metrics_port: Option<u16>,
-    #[serde(default = "default_true")]
-    pub allow_local_bypass: bool,
-}
-
-impl Default for ServerConfig {
-    fn default() -> Self {
-        Self {
-            host: default_host(),
-            port: default_port(),
-            metrics_port: None,
-            allow_local_bypass: default_true(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
-pub struct AuthConfig {
-    #[serde(default)]
-    pub webauthn: WebAuthnConfig,
-    #[serde(default)]
-    pub jwt: JwtConfig,
-    #[serde(default)]
-    pub registration: RegistrationConfig,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct WebAuthnConfig {
-    #[serde(default = "default_rp_id")]
-    pub rp_id: String,
-    #[serde(default = "default_rp_name")]
-    pub rp_name: String,
-    #[serde(default = "default_rp_origin")]
-    pub rp_origin: String,
-    #[serde(default)]
-    pub allowed_origins: Vec<String>,
-}
-
-impl Default for WebAuthnConfig {
-    fn default() -> Self {
-        Self {
-            rp_id: default_rp_id(),
-            rp_name: default_rp_name(),
-            rp_origin: default_rp_origin(),
-            allowed_origins: Vec::new(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct JwtConfig {
-    #[serde(default = "default_jwt_issuer")]
-    pub issuer: String,
-    #[serde(default = "default_jwt_secret")]
-    pub secret: String,
-    #[serde(default = "default_jwt_expiration_hours")]
-    pub expiration_hours: u64,
-}
-
-impl Default for JwtConfig {
-    fn default() -> Self {
-        Self {
-            issuer: default_jwt_issuer(),
-            secret: default_jwt_secret(),
-            expiration_hours: default_jwt_expiration_hours(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
-pub struct RegistrationConfig {
-    #[serde(default)]
-    pub allow_open_registration: bool,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct ProviderConfig {
-    pub name: String,
-    pub provider: String,
-    pub base_url: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub api_key: Option<String>,
-    #[serde(default = "default_timeout")]
-    pub timeout_seconds: u64,
-    #[serde(default)]
-    pub models: Vec<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct TlsForwardConfig {
-    #[serde(default = "default_true")]
-    pub enabled: bool,
-    #[serde(default = "default_tlsforward_addresses")]
-    pub tlsforward_addresses: Vec<String>,
-    #[serde(default = "default_tlsforward_max_connections")]
-    pub max_connections: usize,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub secret_key_path: Option<String>,
-    #[serde(default = "default_heartbeat_interval")]
-    pub heartbeat_interval: u64,
-}
-
-impl Default for TlsForwardConfig {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            tlsforward_addresses: default_tlsforward_addresses(),
-            max_connections: default_tlsforward_max_connections(),
-            secret_key_path: None,
-            heartbeat_interval: default_heartbeat_interval(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct LetsEncryptConfig {
-    #[serde(default = "default_true")]
-    pub enabled: bool,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub email: Option<String>,
-    #[serde(default)]
-    pub staging: bool,
-    #[serde(default)]
-    pub domains: Vec<String>,
-    #[serde(default = "default_auto_renew_days")]
-    pub auto_renew_days: u32,
-}
-
-impl Default for LetsEncryptConfig {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            email: None,
-            staging: false,
-            domains: Vec::new(),
-            auto_renew_days: default_auto_renew_days(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct LocalInferenceConfig {
-    #[serde(default = "default_true")]
-    pub enabled: bool,
-    #[serde(default = "default_max_concurrent_inferences")]
-    pub max_concurrent_inferences: usize,
-    #[serde(default = "default_temperature")]
-    pub default_temperature: f32,
-    #[serde(default = "default_max_tokens")]
-    pub default_max_tokens: u32,
-}
-
-impl Default for LocalInferenceConfig {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            max_concurrent_inferences: default_max_concurrent_inferences(),
-            default_temperature: default_temperature(),
-            default_max_tokens: default_max_tokens(),
-        }
-    }
-}
-
-// Default value functions
-fn default_host() -> String {
-    "127.0.0.1".to_string()
-}
-
-fn default_port() -> u16 {
-    31145
-}
-
-fn default_true() -> bool {
-    true
-}
-
-fn default_rp_id() -> String {
-    "localhost".to_string()
-}
-
-fn default_rp_name() -> String {
-    "Gate Self-Hosted".to_string()
-}
-
-fn default_rp_origin() -> String {
-    format!("http://localhost:{}", default_port())
-}
-
-fn default_jwt_issuer() -> String {
-    "gate-daemon".to_string()
-}
-
-fn default_jwt_secret() -> String {
-    "change-me-in-production".to_string()
-}
-
-fn default_jwt_expiration_hours() -> u64 {
-    24
-}
-
-pub fn default_timeout() -> u64 {
-    30
-}
-
-fn default_tlsforward_addresses() -> Vec<String> {
-    vec![
-        "3dbefb2e3d56c7e32586d9a82167a8a5151f3e0f4b40b7c3d145b9060dde2f14@213.239.212.173:31145"
-            .to_string(),
-    ]
-}
-
-fn default_tlsforward_max_connections() -> usize {
-    1000
-}
-
-fn default_heartbeat_interval() -> u64 {
-    30
-}
-
-fn default_auto_renew_days() -> u32 {
-    30
-}
-
-fn default_max_concurrent_inferences() -> usize {
-    4
-}
-
-fn default_temperature() -> f32 {
-    0.7
-}
-
-fn default_max_tokens() -> u32 {
-    2048
-}
diff --git a/crates/frontend-daemon/src/components/mod.rs b/crates/frontend-daemon/src/components/mod.rs
deleted file mode 100644
index 5a0f58d8..00000000
--- a/crates/frontend-daemon/src/components/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-mod config_editor;
-pub mod user_management;
-
-pub use config_editor::ConfigEditor;
-pub use user_management::UserManagementContainer;
diff --git a/crates/frontend-daemon/src/components/user_management/container.rs b/crates/frontend-daemon/src/components/user_management/container.rs
deleted file mode 100644
index ee2c7ee4..00000000
--- a/crates/frontend-daemon/src/components/user_management/container.rs
+++ /dev/null
@@ -1,230 +0,0 @@
-//! User management container component
-
-use super::detail::UserDetail;
-use super::list::UserList;
-use crate::services::user::{UserInfo, UserService};
-use gate_frontend_common::auth::use_auth;
-use gloo::timers::callback::Timeout;
-use yew::prelude::*;
-
-pub enum View {
-    List,
-    Detail(String),
-}
-
-#[function_component(UserManagementContainer)]
-pub fn user_management_container() -> Html {
-    let auth = use_auth();
-    let user_service = use_memo((), |_| UserService::new());
-
-    let users = use_state(Vec::<UserInfo>::new);
-    let view = use_state(|| View::List);
-    let is_loading = use_state(|| true);
-    let error = use_state(|| Option::<String>::None);
-    let success = use_state(|| Option::<String>::None);
-
-    let current_user_id = auth
-        .auth_state
-        .as_ref()
-        .map(|s| s.user_id.clone())
-        .unwrap_or_default();
-
-    // For now, treat all authenticated users as having manage permission
-    // TODO: Check actual permissions from backend
-    let can_manage_users = true;
-
-    // Load users effect
-    {
-        let users = users.clone();
-        let is_loading = is_loading.clone();
-        let error = error.clone();
-        let user_service = user_service.clone();
-
-        use_effect_with((), move |_| {
-            wasm_bindgen_futures::spawn_local(async move {
-                is_loading.set(true);
-                match user_service.list_users(1, 50, None).await {
-                    Ok(response) => {
-                        users.set(response.users);
-                        error.set(None);
-                    }
-                    Err(e) => {
-                        error.set(Some(format!("Failed to load users: {e}")));
-                    }
-                }
-                is_loading.set(false);
-            });
-        });
-    }
-
-    // Clear success message after timeout
-    {
-        let success = success.clone();
-        use_effect_with(success.clone(), move |msg| {
-            if msg.is_some() {
-                let success = success.clone();
-                Timeout::new(3000, move || {
-                    success.set(None);
-                })
-                .forget();
-            }
-        });
-    }
-
-    let reload_users = {
-        let users = users.clone();
-        let user_service = user_service.clone();
-        let error = error.clone();
-
-        Callback::from(move |_: ()| {
-            let users = users.clone();
-            let user_service = user_service.clone();
-            let error = error.clone();
-
-            wasm_bindgen_futures::spawn_local(async move {
-                match user_service.list_users(1, 50, None).await {
-                    Ok(response) => {
-                        users.set(response.users);
-                        error.set(None);
-                    }
-                    Err(e) => {
-                        error.set(Some(format!("Failed to reload users: {e}")));
-                    }
-                }
-            });
-        })
-    };
-
-    let on_user_select = {
-        let view = view.clone();
-        Callback::from(move |user_id: String| {
-            view.set(View::Detail(user_id));
-        })
-    };
-
-    let on_user_delete = {
-        let user_service = user_service.clone();
-        let error = error.clone();
-        let success = success.clone();
-        let reload = reload_users.clone();
-
-        Callback::from(move |user_id: String| {
-            if web_sys::window()
-                .and_then(|w| {
-                    w.confirm_with_message(&format!("Delete user {user_id}?"))
-                        .ok()
-                })
-                .unwrap_or(false)
-            {
-                let user_service = user_service.clone();
-                let error = error.clone();
-                let success = success.clone();
-                let reload = reload.clone();
-
-                wasm_bindgen_futures::spawn_local(async move {
-                    match user_service.delete_user(&user_id).await {
-                        Ok(_) => {
-                            success.set(Some(format!("User {user_id} deleted")));
-                            reload.emit(());
-                        }
-                        Err(e) => {
-                            error.set(Some(format!("Failed to delete user: {e}")));
-                        }
-                    }
-                });
-            }
-        })
-    };
-
-    let on_user_toggle = {
-        let user_service = user_service.clone();
-        let error = error.clone();
-        let success = success.clone();
-        let reload = reload_users.clone();
-
-        Callback::from(move |(user_id, enabled): (String, bool)| {
-            let user_service = user_service.clone();
-            let error = error.clone();
-            let success = success.clone();
-            let reload = reload.clone();
-
-            wasm_bindgen_futures::spawn_local(async move {
-                match user_service.update_user_status(&user_id, enabled).await {
-                    Ok(_) => {
-                        success.set(Some(format!(
-                            "User {} {}",
-                            user_id,
-                            if enabled { "enabled" } else { "disabled" }
-                        )));
-                        reload.emit(());
-                    }
-                    Err(e) => {
-                        error.set(Some(format!("Failed to update user status: {e}")));
-                    }
-                }
-            });
-        })
-    };
-
-    let on_search = Callback::from(move |_search: String| {
-        // TODO: Implement search
-    });
-
-    html! {
-        <div class="p-6 max-w-7xl mx-auto">
-            <div class="mb-6">
-                <h1 class="text-2xl font-bold text-gray-900 dark:text-gray-100">
-                    {"User Management"}
-                </h1>
-                <p class="mt-1 text-sm text-gray-600 dark:text-gray-400">
-                    {"Manage user accounts and permissions"}
-                </p>
-            </div>
-
-            {if let Some(err) = (*error).as_ref() {
-                html! {
-                    <div class="mb-4 p-4 bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 rounded-md">
-                        <p class="text-red-700 dark:text-red-300">{err}</p>
-                    </div>
-                }
-            } else {
-                html! {}
-            }}
-
-            {if let Some(msg) = (*success).as_ref() {
-                html! {
-                    <div class="mb-4 p-4 bg-green-50 dark:bg-green-900/20 border border-green-200 dark:border-green-800 rounded-md">
-                        <p class="text-green-700 dark:text-green-300">{msg}</p>
-                    </div>
-                }
-            } else {
-                html! {}
-            }}
-
-            {match &*view {
-                View::List => html! {
-                    <UserList
-                        users={(*users).clone()}
-                        is_loading={*is_loading}
-                        current_user_id={current_user_id}
-                        on_user_select={on_user_select}
-                        on_user_delete={on_user_delete}
-                        on_user_toggle={on_user_toggle}
-                        on_search={on_search}
-                        can_manage_users={can_manage_users}
-                    />
-                },
-                View::Detail(user_id) => {
-                    let view_clone = view.clone();
-                    html! {
-                        <UserDetail
-                            user_id={user_id.clone()}
-                            on_back={Callback::from(move |_| view_clone.set(View::List))}
-                            can_manage_permissions={can_manage_users}
-                        />
-                    }
-                }
-            }}
-        </div>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/user_management/detail.rs b/crates/frontend-daemon/src/components/user_management/detail.rs
deleted file mode 100644
index 1ad2b3ec..00000000
--- a/crates/frontend-daemon/src/components/user_management/detail.rs
+++ /dev/null
@@ -1,519 +0,0 @@
-//! User detail view with permission management
-
-use super::shared::{ActionButton, ActionButtonVariant, EmptyState, StatusBadge};
-use crate::services::user::{UserInfo, UserPermission, UserService};
-use gloo::timers::callback::Timeout;
-use yew::functional::use_memo;
-use yew::prelude::*;
-
-#[derive(Properties, PartialEq)]
-pub struct UserDetailProps {
-    pub user_id: String,
-    pub on_back: Callback<()>,
-    pub can_manage_permissions: bool,
-}
-
-#[function_component(UserDetail)]
-pub fn user_detail(props: &UserDetailProps) -> Html {
-    let user_service = use_memo((), |_| UserService::new());
-
-    let user = use_state(|| Option::<UserInfo>::None);
-    let permissions = use_state(Vec::<UserPermission>::new);
-    let is_loading = use_state(|| true);
-    let error = use_state(|| Option::<String>::None);
-    let success = use_state(|| Option::<String>::None);
-    let show_add_permission = use_state(|| false);
-
-    // Load user data
-    {
-        let user_id = props.user_id.clone();
-        let user_service = user_service.clone();
-        let user = user.clone();
-        let permissions = permissions.clone();
-        let is_loading = is_loading.clone();
-        let error = error.clone();
-
-        use_effect_with(user_id.clone(), move |_| {
-            wasm_bindgen_futures::spawn_local(async move {
-                is_loading.set(true);
-
-                // Load user info
-                match user_service.get_user(&user_id).await {
-                    Ok(user_info) => {
-                        user.set(Some(user_info));
-                    }
-                    Err(e) => {
-                        error.set(Some(format!("Failed to load user: {e}")));
-                    }
-                }
-
-                // Load permissions
-                match user_service.get_user_permissions(&user_id).await {
-                    Ok(perms) => {
-                        permissions.set(perms);
-                    }
-                    Err(e) => {
-                        error.set(Some(format!("Failed to load permissions: {e}")));
-                    }
-                }
-
-                is_loading.set(false);
-            });
-        });
-    }
-
-    // Clear success message after timeout
-    {
-        let success = success.clone();
-        use_effect_with(success.clone(), move |msg| {
-            if msg.is_some() {
-                let success = success.clone();
-                Timeout::new(3000, move || {
-                    success.set(None);
-                })
-                .forget();
-            }
-        });
-    }
-
-    let on_toggle_status = {
-        let user = user.clone();
-        let user_service = user_service.clone();
-        let error = error.clone();
-        let success = success.clone();
-        let user_id = props.user_id.clone();
-
-        Callback::from(move |_| {
-            if let Some(user_info) = (*user).as_ref() {
-                let enabled = !user_info.enabled;
-                let user_service = user_service.clone();
-                let user = user.clone();
-                let error = error.clone();
-                let success = success.clone();
-                let user_id = user_id.clone();
-
-                wasm_bindgen_futures::spawn_local(async move {
-                    match user_service.update_user_status(&user_id, enabled).await {
-                        Ok(updated_user) => {
-                            user.set(Some(updated_user));
-                            success.set(Some(format!(
-                                "User {}",
-                                if enabled { "enabled" } else { "disabled" }
-                            )));
-                        }
-                        Err(e) => {
-                            error.set(Some(format!("Failed to update status: {e}")));
-                        }
-                    }
-                });
-            }
-        })
-    };
-
-    let on_revoke_permission = {
-        let user_id = props.user_id.clone();
-        let user_service = user_service.clone();
-        let permissions = permissions.clone();
-        let error = error.clone();
-        let success = success.clone();
-
-        Callback::from(move |perm: UserPermission| {
-            let user_service = user_service.clone();
-            let permissions = permissions.clone();
-            let error = error.clone();
-            let success = success.clone();
-            let user_id = user_id.clone();
-
-            wasm_bindgen_futures::spawn_local(async move {
-                match user_service
-                    .revoke_permission(&user_id, &perm.action, &perm.object)
-                    .await
-                {
-                    Ok(_) => {
-                        // Reload permissions
-                        match user_service.get_user_permissions(&user_id).await {
-                            Ok(perms) => {
-                                permissions.set(perms);
-                                success.set(Some("Permission revoked".to_string()));
-                            }
-                            Err(e) => {
-                                error.set(Some(format!("Failed to reload permissions: {e}")));
-                            }
-                        }
-                    }
-                    Err(e) => {
-                        error.set(Some(format!("Failed to revoke permission: {e}")));
-                    }
-                }
-            });
-        })
-    };
-
-    if *is_loading {
-        return html! {
-            <div class="flex justify-center items-center h-64">
-                <div class="animate-spin rounded-full h-8 w-8 border-b-2 border-blue-500"></div>
-            </div>
-        };
-    }
-
-    let Some(user_info) = (*user).as_ref() else {
-        return html! {
-            <div class="text-center py-12">
-                <p class="text-red-600 dark:text-red-400">{"User not found"}</p>
-                <button
-                    onclick={props.on_back.reform(|_| ())}
-                    class="mt-4 text-blue-600 hover:text-blue-800"
-                >
-                    {"← Back to list"}
-                </button>
-            </div>
-        };
-    };
-
-    html! {
-        <div class="space-y-6">
-            // Back button
-            <button
-                onclick={props.on_back.reform(|_| ())}
-                class="text-blue-600 hover:text-blue-800 dark:text-blue-400 dark:hover:text-blue-300 flex items-center"
-            >
-                <svg class="w-4 h-4 mr-1" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15 19l-7-7 7-7" />
-                </svg>
-                {"Back to users"}
-            </button>
-
-            // Messages
-            {if let Some(err) = (*error).as_ref() {
-                html! {
-                    <div class="p-4 bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 rounded-md">
-                        <p class="text-red-700 dark:text-red-300">{err}</p>
-                    </div>
-                }
-            } else {
-                html! {}
-            }}
-
-            {if let Some(msg) = (*success).as_ref() {
-                html! {
-                    <div class="p-4 bg-green-50 dark:bg-green-900/20 border border-green-200 dark:border-green-800 rounded-md">
-                        <p class="text-green-700 dark:text-green-300">{msg}</p>
-                    </div>
-                }
-            } else {
-                html! {}
-            }}
-
-            // User info card
-            <div class="bg-white dark:bg-gray-800 rounded-lg shadow">
-                <div class="px-6 py-4 border-b border-gray-200 dark:border-gray-700">
-                    <div class="flex items-center justify-between">
-                        <div class="flex items-center space-x-4">
-                            <div class="w-16 h-16 bg-blue-600 rounded-full flex items-center justify-center text-white font-bold text-2xl">
-                                {user_info.name.as_ref()
-                                    .and_then(|n| n.chars().next())
-                                    .unwrap_or_else(|| user_info.id.chars().next().unwrap_or('?'))
-                                    .to_uppercase().to_string()}
-                            </div>
-                            <div>
-                                <h2 class="text-xl font-semibold text-gray-900 dark:text-gray-100">
-                                    {user_info.name.as_deref().unwrap_or(&user_info.id)}
-                                </h2>
-                                <p class="text-sm text-gray-500 dark:text-gray-400">
-                                    {&user_info.id}
-                                </p>
-                            </div>
-                        </div>
-                        <StatusBadge enabled={user_info.enabled} />
-                    </div>
-                </div>
-
-                <div class="px-6 py-4 space-y-4">
-                    <div class="grid grid-cols-2 gap-4 text-sm">
-                        <div>
-                            <p class="text-gray-500 dark:text-gray-400">{"Created"}</p>
-                            <p class="text-gray-900 dark:text-gray-100">
-                                {user_info.created_at.format("%Y-%m-%d %H:%M").to_string()}
-                            </p>
-                        </div>
-                        <div>
-                            <p class="text-gray-500 dark:text-gray-400">{"Last Updated"}</p>
-                            <p class="text-gray-900 dark:text-gray-100">
-                                {user_info.updated_at.format("%Y-%m-%d %H:%M").to_string()}
-                            </p>
-                        </div>
-                        {if let Some(disabled_at) = user_info.disabled_at {
-                            html! {
-                                <div>
-                                    <p class="text-gray-500 dark:text-gray-400">{"Disabled At"}</p>
-                                    <p class="text-gray-900 dark:text-gray-100">
-                                        {disabled_at.format("%Y-%m-%d %H:%M").to_string()}
-                                    </p>
-                                </div>
-                            }
-                        } else {
-                            html! {}
-                        }}
-                    </div>
-
-                    <div class="flex space-x-3">
-                        <ActionButton
-                            label={if user_info.enabled { "Disable User" } else { "Enable User" }}
-                            icon={html! {
-                                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
-                                        d={if user_info.enabled {
-                                            "M18.364 18.364A9 9 0 005.636 5.636m12.728 12.728A9 9 0 015.636 5.636m12.728 12.728L5.636 5.636"
-                                        } else {
-                                            "M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z"
-                                        }} />
-                                </svg>
-                            }}
-                            on_click={on_toggle_status}
-                            enabled={true}
-                            variant={if user_info.enabled { ActionButtonVariant::Danger } else { ActionButtonVariant::Primary }}
-                        />
-                    </div>
-                </div>
-            </div>
-
-            // Permissions section
-            <div class="bg-white dark:bg-gray-800 rounded-lg shadow">
-                <div class="px-6 py-4 border-b border-gray-200 dark:border-gray-700">
-                    <div class="flex items-center justify-between">
-                        <h3 class="text-lg font-medium text-gray-900 dark:text-gray-100">
-                            {"Permissions"}
-                        </h3>
-                        {if props.can_manage_permissions {
-                            let show_add = show_add_permission.clone();
-                            html! {
-                                <button
-                                    onclick={Callback::from(move |_| show_add.set(true))}
-                                    class="px-3 py-1 bg-blue-600 text-white text-sm rounded hover:bg-blue-700"
-                                >
-                                    {"+ Grant Permission"}
-                                </button>
-                            }
-                        } else {
-                            html! {}
-                        }}
-                    </div>
-                </div>
-
-                <div class="px-6 py-4">
-                    {if permissions.is_empty() {
-                        html! {
-                            <EmptyState
-                                title="No permissions"
-                                description="This user has no explicit permissions granted"
-                                icon={html! {
-                                    <svg fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
-                                            d="M12 15v2m-6 4h12a2 2 0 002-2v-6a2 2 0 00-2-2H6a2 2 0 00-2 2v6a2 2 0 002 2zm10-10V7a4 4 0 00-8 0v4h8z" />
-                                    </svg>
-                                }}
-                            />
-                        }
-                    } else {
-                        html! {
-                            <div class="space-y-2">
-                                {permissions.iter().map(|perm| {
-                                    let perm_clone = perm.clone();
-                                    html! {
-                                        <div key={format!("{}-{}", perm.action, perm.object)}
-                                             class="flex items-center justify-between p-3 bg-gray-50 dark:bg-gray-900 rounded-lg">
-                                            <div>
-                                                <p class="font-medium text-gray-900 dark:text-gray-100">
-                                                    {&perm.action}
-                                                </p>
-                                                <p class="text-sm text-gray-500 dark:text-gray-400">
-                                                    {&perm.object}
-                                                </p>
-                                                <p class="text-xs text-gray-400 dark:text-gray-500 mt-1">
-                                                    {format!("Granted: {}", perm.granted_at.format("%Y-%m-%d %H:%M"))}
-                                                </p>
-                                            </div>
-                                            {if props.can_manage_permissions {
-                                                html! {
-                                                    <button
-                                                        onclick={on_revoke_permission.reform(move |_| perm_clone.clone())}
-                                                        class="text-red-600 hover:text-red-800 dark:text-red-400 dark:hover:text-red-300"
-                                                    >
-                                                        {"Revoke"}
-                                                    </button>
-                                                }
-                                            } else {
-                                                html! {}
-                                            }}
-                                        </div>
-                                    }
-                                }).collect::<Html>()}
-                            </div>
-                        }
-                    }}
-                </div>
-            </div>
-
-            // Add Permission Modal
-            {if *show_add_permission {
-                let show_add_permission_close = show_add_permission.clone();
-                let show_add_permission_grant = show_add_permission.clone();
-                let permissions = permissions.clone();
-                let user_service = user_service.clone();
-                let user_id = props.user_id.clone();
-
-                html! {
-                    <PermissionGrantModal
-                        user_id={props.user_id.clone()}
-                        on_close={Callback::from(move |_| show_add_permission_close.set(false))}
-                        on_grant={Callback::from(move |_| {
-                            show_add_permission_grant.set(false);
-                            // Reload permissions
-                            let user_service = user_service.clone();
-                            let permissions = permissions.clone();
-                            let user_id = user_id.clone();
-                            wasm_bindgen_futures::spawn_local(async move {
-                                if let Ok(perms) = user_service.get_user_permissions(&user_id).await {
-                                    permissions.set(perms);
-                                }
-                            });
-                        })}
-                    />
-                }
-            } else {
-                html! {}
-            }}
-        </div>
-    }
-}
-
-#[derive(Properties, PartialEq)]
-struct PermissionGrantModalProps {
-    user_id: String,
-    on_close: Callback<()>,
-    on_grant: Callback<()>,
-}
-
-#[function_component(PermissionGrantModal)]
-fn permission_grant_modal(props: &PermissionGrantModalProps) -> Html {
-    let action = use_state(|| "Read".to_string());
-    let object = use_state(|| "local/System/*".to_string());
-
-    let available_actions = [
-        "Read",
-        "Write",
-        "Delete",
-        "Execute",
-        "Manage",
-        "GrantPermission",
-        "RevokePermission",
-        "ViewPermissions",
-    ];
-
-    let on_submit = {
-        let user_service = UserService::new();
-        let user_id = props.user_id.clone();
-        let action = action.clone();
-        let object = object.clone();
-        let on_grant = props.on_grant.clone();
-
-        Callback::from(move |e: SubmitEvent| {
-            e.prevent_default();
-
-            let user_service = user_service.clone();
-            let user_id = user_id.clone();
-            let action_val = (*action).clone();
-            let object_val = (*object).clone();
-            let on_grant = on_grant.clone();
-
-            wasm_bindgen_futures::spawn_local(async move {
-                match user_service
-                    .grant_permission(&user_id, &action_val, &object_val)
-                    .await
-                {
-                    Ok(_) => {
-                        on_grant.emit(());
-                    }
-                    Err(e) => {
-                        web_sys::window().and_then(|w| {
-                            w.alert_with_message(&format!("Failed to grant permission: {e}"))
-                                .ok()
-                        });
-                    }
-                }
-            });
-        })
-    };
-
-    html! {
-        <div class="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50">
-            <div class="bg-white dark:bg-gray-800 rounded-lg p-6 max-w-md w-full mx-4">
-                <h3 class="text-lg font-semibold mb-4">{"Grant Permission"}</h3>
-
-                <form onsubmit={on_submit}>
-                    <div class="space-y-4">
-                        <div>
-                            <label class="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-1">
-                                {"Action"}
-                            </label>
-                            <select
-                                class="w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-md
-                                       bg-white dark:bg-gray-700 text-gray-900 dark:text-gray-100"
-                                value={(*action).clone()}
-                                onchange={{
-                                    let action = action.clone();
-                                    Callback::from(move |e: Event| {
-                                        let select: web_sys::HtmlSelectElement = e.target_unchecked_into();
-                                        action.set(select.value());
-                                    })
-                                }}
-                            >
-                                {available_actions.iter().map(|a| html! {
-                                    <option value={a.to_string()}>{a.to_string()}</option>
-                                }).collect::<Html>()}
-                            </select>
-                        </div>
-
-                        <div>
-                            <label class="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-1">
-                                {"Object (namespace/kind/id)"}
-                            </label>
-                            <input
-                                type="text"
-                                class="w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-md
-                                       bg-white dark:bg-gray-700 text-gray-900 dark:text-gray-100"
-                                value={(*object).clone()}
-                                oninput={{
-                                    let object = object.clone();
-                                    Callback::from(move |e: InputEvent| {
-                                        let input: web_sys::HtmlInputElement = e.target_unchecked_into();
-                                        object.set(input.value());
-                                    })
-                                }}
-                                placeholder="e.g., local/System/*, system/User/user123"
-                            />
-                        </div>
-                    </div>
-
-                    <div class="mt-6 flex justify-end space-x-3">
-                        <button
-                            type="button"
-                            onclick={props.on_close.reform(|_| ())}
-                            class="px-4 py-2 text-gray-700 dark:text-gray-300 bg-gray-100 dark:bg-gray-700
-                                   hover:bg-gray-200 dark:hover:bg-gray-600 rounded-md"
-                        >
-                            {"Cancel"}
-                        </button>
-                        <button
-                            type="submit"
-                            class="px-4 py-2 bg-blue-600 text-white hover:bg-blue-700 rounded-md"
-                        >
-                            {"Grant"}
-                        </button>
-                    </div>
-                </form>
-            </div>
-        </div>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/user_management/list.rs b/crates/frontend-daemon/src/components/user_management/list.rs
deleted file mode 100644
index bd1544e5..00000000
--- a/crates/frontend-daemon/src/components/user_management/list.rs
+++ /dev/null
@@ -1,196 +0,0 @@
-//! User list view component
-
-use super::shared::{EmptyState, StatusBadge, UserListSkeleton};
-use crate::services::user::UserInfo;
-use web_sys::HtmlInputElement;
-use yew::prelude::*;
-
-#[derive(Properties, PartialEq)]
-pub struct UserListProps {
-    pub users: Vec<UserInfo>,
-    pub is_loading: bool,
-    pub current_user_id: String,
-    pub on_user_select: Callback<String>,
-    pub on_user_delete: Callback<String>,
-    pub on_user_toggle: Callback<(String, bool)>,
-    pub on_search: Callback<String>,
-    pub can_manage_users: bool,
-}
-
-#[function_component(UserList)]
-pub fn user_list(props: &UserListProps) -> Html {
-    let search_value = use_state(String::new);
-
-    let on_search_input = {
-        let search_value = search_value.clone();
-        let on_search = props.on_search.clone();
-        Callback::from(move |e: InputEvent| {
-            let input: HtmlInputElement = e.target_unchecked_into();
-            let value = input.value();
-            search_value.set(value.clone());
-            on_search.emit(value);
-        })
-    };
-
-    if props.is_loading {
-        return html! { <UserListSkeleton /> };
-    }
-
-    if props.users.is_empty() {
-        return html! {
-            <EmptyState
-                title="No users found"
-                description={if (*search_value).is_empty() {
-                    "No users have been created yet.".to_string()
-                } else {
-                    format!("No users match '{}'", *search_value)
-                }}
-                icon={html! {
-                    <svg fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
-                            d="M12 4.354a4 4 0 110 5.292M15 21H3v-1a6 6 0 0112 0v1zm0 0h6v-1a6 6 0 00-9-5.197M13 7a4 4 0 11-8 0 4 4 0 018 0z" />
-                    </svg>
-                }}
-            />
-        };
-    }
-
-    html! {
-        <div class="space-y-4">
-            // Search bar
-            <div class="relative">
-                <div class="absolute inset-y-0 left-0 pl-3 flex items-center pointer-events-none">
-                    <svg class="h-5 w-5 text-gray-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
-                            d="M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z" />
-                    </svg>
-                </div>
-                <input
-                    type="text"
-                    class="block w-full pl-10 pr-3 py-2 border border-gray-300 dark:border-gray-600
-                           rounded-md leading-5 bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100
-                           placeholder-gray-500 focus:outline-none focus:placeholder-gray-400 
-                           focus:ring-1 focus:ring-blue-500 focus:border-blue-500 sm:text-sm"
-                    placeholder="Search users..."
-                    value={(*search_value).clone()}
-                    oninput={on_search_input}
-                />
-            </div>
-
-            // User list
-            <div class="bg-white dark:bg-gray-800 shadow overflow-hidden rounded-lg">
-                <table class="min-w-full divide-y divide-gray-200 dark:divide-gray-700">
-                    <thead class="bg-gray-50 dark:bg-gray-900">
-                        <tr>
-                            <th scope="col" class="px-6 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider">
-                                {"User"}
-                            </th>
-                            <th scope="col" class="px-6 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider">
-                                {"Status"}
-                            </th>
-                            <th scope="col" class="px-6 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider">
-                                {"Created"}
-                            </th>
-                            <th scope="col" class="relative px-6 py-3">
-                                <span class="sr-only">{"Actions"}</span>
-                            </th>
-                        </tr>
-                    </thead>
-                    <tbody class="bg-white dark:bg-gray-800 divide-y divide-gray-200 dark:divide-gray-700">
-                        {props.users.iter().map(|user| {
-                            let is_current_user = user.id == props.current_user_id;
-                            let user_id = user.id.clone();
-
-                            let on_view = {
-                                let user_id = user_id.clone();
-                                let on_select = props.on_user_select.clone();
-                                Callback::from(move |_| on_select.emit(user_id.clone()))
-                            };
-
-                            let on_toggle = {
-                                let user_id = user_id.clone();
-                                let enabled = user.enabled;
-                                let on_toggle = props.on_user_toggle.clone();
-                                Callback::from(move |_| on_toggle.emit((user_id.clone(), !enabled)))
-                            };
-
-                            let on_delete = {
-                                let user_id = user_id.clone();
-                                let on_delete = props.on_user_delete.clone();
-                                Callback::from(move |_| on_delete.emit(user_id.clone()))
-                            };
-
-                            html! {
-                                <tr key={user.id.clone()}>
-                                    <td class="px-6 py-4 whitespace-nowrap">
-                                        <div class="flex items-center">
-                                            <div class="flex-shrink-0 h-10 w-10">
-                                                <div class="h-10 w-10 bg-blue-600 rounded-full flex items-center justify-center text-white font-semibold">
-                                                    {user.name.as_ref()
-                                                        .and_then(|n| n.chars().next())
-                                                        .unwrap_or_else(|| user.id.chars().next().unwrap_or('?'))
-                                                        .to_uppercase().to_string()}
-                                                </div>
-                                            </div>
-                                            <div class="ml-4">
-                                                <div class="text-sm font-medium text-gray-900 dark:text-gray-100">
-                                                    {user.name.as_deref().unwrap_or(&user.id)}
-                                                    {if is_current_user {
-                                                        html! { <span class="ml-2 text-xs text-gray-500">{"(You)"}</span> }
-                                                    } else {
-                                                        html! {}
-                                                    }}
-                                                </div>
-                                                <div class="text-sm text-gray-500 dark:text-gray-400">
-                                                    {&user.id}
-                                                </div>
-                                            </div>
-                                        </div>
-                                    </td>
-                                    <td class="px-6 py-4 whitespace-nowrap">
-                                        <StatusBadge enabled={user.enabled} />
-                                    </td>
-                                    <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500 dark:text-gray-400">
-                                        {user.created_at.format("%Y-%m-%d").to_string()}
-                                    </td>
-                                    <td class="px-6 py-4 whitespace-nowrap text-right text-sm font-medium">
-                                        <div class="flex items-center justify-end space-x-2">
-                                            <button
-                                                onclick={on_view}
-                                                class="text-blue-600 hover:text-blue-900 dark:text-blue-400 dark:hover:text-blue-300"
-                                            >
-                                                {"View"}
-                                            </button>
-                                            {if props.can_manage_users && !is_current_user {
-                                                html! {
-                                                    <>
-                                                        <span class="text-gray-300 dark:text-gray-600">{"|"}</span>
-                                                        <button
-                                                            onclick={on_toggle}
-                                                            class="text-yellow-600 hover:text-yellow-900 dark:text-yellow-400 dark:hover:text-yellow-300"
-                                                        >
-                                                            {if user.enabled { "Disable" } else { "Enable" }}
-                                                        </button>
-                                                        <span class="text-gray-300 dark:text-gray-600">{"|"}</span>
-                                                        <button
-                                                            onclick={on_delete}
-                                                            class="text-red-600 hover:text-red-900 dark:text-red-400 dark:hover:text-red-300"
-                                                        >
-                                                            {"Delete"}
-                                                        </button>
-                                                    </>
-                                                }
-                                            } else {
-                                                html! {}
-                                            }}
-                                        </div>
-                                    </td>
-                                </tr>
-                            }
-                        }).collect::<Html>()}
-                    </tbody>
-                </table>
-            </div>
-        </div>
-    }
-}
diff --git a/crates/frontend-daemon/src/components/user_management/mod.rs b/crates/frontend-daemon/src/components/user_management/mod.rs
deleted file mode 100644
index c1785d6d..00000000
--- a/crates/frontend-daemon/src/components/user_management/mod.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-pub mod container;
-pub mod detail;
-pub mod list;
-pub mod shared;
-
-pub use container::UserManagementContainer;
diff --git a/crates/frontend-daemon/src/components/user_management/shared.rs b/crates/frontend-daemon/src/components/user_management/shared.rs
deleted file mode 100644
index 2edc6279..00000000
--- a/crates/frontend-daemon/src/components/user_management/shared.rs
+++ /dev/null
@@ -1,228 +0,0 @@
-//! Shared UI components for user management
-
-use crate::services::user::UserInfo;
-use yew::prelude::*;
-
-/// Status badge component
-#[derive(Properties, PartialEq)]
-pub struct StatusBadgeProps {
-    pub enabled: bool,
-}
-
-#[function_component(StatusBadge)]
-pub fn status_badge(props: &StatusBadgeProps) -> Html {
-    let (class, text) = if props.enabled {
-        (
-            "inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-green-100 text-green-800 dark:bg-green-900/30 dark:text-green-400",
-            "Active"
-        )
-    } else {
-        (
-            "inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-red-100 text-red-800 dark:bg-red-900/30 dark:text-red-400",
-            "Disabled"
-        )
-    };
-
-    html! {
-        <span class={class}>
-            {text}
-        </span>
-    }
-}
-
-/// User card component for consistent display
-#[derive(Properties, PartialEq)]
-pub struct UserCardProps {
-    pub user: UserInfo,
-    pub on_click: Option<Callback<String>>,
-    pub compact: bool,
-}
-
-#[function_component(UserCard)]
-pub fn user_card(props: &UserCardProps) -> Html {
-    let on_click = {
-        let user_id = props.user.id.clone();
-        let callback = props.on_click.clone();
-        Callback::from(move |e: MouseEvent| {
-            e.prevent_default();
-            if let Some(cb) = &callback {
-                cb.emit(user_id.clone());
-            }
-        })
-    };
-
-    if props.compact {
-        html! {
-            <div
-                class="flex items-center justify-between p-3 hover:bg-gray-50 dark:hover:bg-gray-800 cursor-pointer rounded-lg transition-colors"
-                onclick={on_click}
-            >
-                <div class="flex items-center space-x-3">
-                    <div class="flex-shrink-0">
-                        <div class="w-10 h-10 bg-blue-600 rounded-full flex items-center justify-center text-white font-semibold">
-                            {props.user.name.as_ref()
-                                .and_then(|n| n.chars().next())
-                                .unwrap_or_else(|| props.user.id.chars().next().unwrap_or('?'))
-                                .to_uppercase().to_string()}
-                        </div>
-                    </div>
-                    <div>
-                        <p class="text-sm font-medium text-gray-900 dark:text-gray-100">
-                            {props.user.name.as_deref().unwrap_or(&props.user.id)}
-                        </p>
-                        <p class="text-xs text-gray-500 dark:text-gray-400">
-                            {&props.user.id}
-                        </p>
-                    </div>
-                </div>
-                <StatusBadge enabled={props.user.enabled} />
-            </div>
-        }
-    } else {
-        html! {
-            <div
-                class="bg-white dark:bg-gray-800 rounded-lg shadow p-6 hover:shadow-md transition-shadow cursor-pointer"
-                onclick={on_click}
-            >
-                <div class="flex items-start justify-between">
-                    <div class="flex items-center space-x-4">
-                        <div class="flex-shrink-0">
-                            <div class="w-12 h-12 bg-blue-600 rounded-full flex items-center justify-center text-white font-semibold text-lg">
-                                {props.user.name.as_ref()
-                                    .and_then(|n| n.chars().next())
-                                    .unwrap_or_else(|| props.user.id.chars().next().unwrap_or('?'))
-                                    .to_uppercase().to_string()}
-                            </div>
-                        </div>
-                        <div>
-                            <h3 class="text-lg font-medium text-gray-900 dark:text-gray-100">
-                                {props.user.name.as_deref().unwrap_or(&props.user.id)}
-                            </h3>
-                            <p class="text-sm text-gray-500 dark:text-gray-400">
-                                {&props.user.id}
-                            </p>
-                            <p class="text-xs text-gray-400 dark:text-gray-500 mt-1">
-                                {format!("Created: {}", props.user.created_at.format("%Y-%m-%d"))}
-                            </p>
-                        </div>
-                    </div>
-                    <StatusBadge enabled={props.user.enabled} />
-                </div>
-            </div>
-        }
-    }
-}
-
-/// Action button with permission awareness
-#[derive(Properties, PartialEq)]
-pub struct ActionButtonProps {
-    pub label: String,
-    pub icon: Html,
-    pub on_click: Callback<()>,
-    pub enabled: bool,
-    pub variant: ActionButtonVariant,
-    #[prop_or_default]
-    pub tooltip: Option<String>,
-}
-
-#[derive(Clone, PartialEq)]
-pub enum ActionButtonVariant {
-    Primary,
-    Danger,
-}
-
-#[function_component(ActionButton)]
-pub fn action_button(props: &ActionButtonProps) -> Html {
-    let on_click = {
-        let callback = props.on_click.clone();
-        Callback::from(move |e: MouseEvent| {
-            e.prevent_default();
-            callback.emit(());
-        })
-    };
-
-    let base_class = "inline-flex items-center px-3 py-2 border text-sm font-medium rounded-md transition-colors";
-    let variant_class = match props.variant {
-        ActionButtonVariant::Primary => {
-            if props.enabled {
-                "border-transparent bg-blue-600 text-white hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500"
-            } else {
-                "border-gray-300 bg-gray-100 text-gray-400 cursor-not-allowed"
-            }
-        }
-        ActionButtonVariant::Danger => {
-            if props.enabled {
-                "border-transparent bg-red-600 text-white hover:bg-red-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-red-500"
-            } else {
-                "border-gray-300 bg-gray-100 text-gray-400 cursor-not-allowed"
-            }
-        }
-    };
-
-    html! {
-        <button
-            class={format!("{} {}", base_class, variant_class)}
-            onclick={on_click}
-            disabled={!props.enabled}
-            title={props.tooltip.clone()}
-        >
-            <span class="mr-2">{props.icon.clone()}</span>
-            {&props.label}
-        </button>
-    }
-}
-
-/// Empty state component
-#[derive(Properties, PartialEq)]
-pub struct EmptyStateProps {
-    pub title: String,
-    pub description: String,
-    pub icon: Html,
-    #[prop_or_default]
-    pub action: Option<Html>,
-}
-
-#[function_component(EmptyState)]
-pub fn empty_state(props: &EmptyStateProps) -> Html {
-    html! {
-        <div class="text-center py-12">
-            <div class="flex justify-center mb-4">
-                <div class="w-12 h-12 text-gray-400">
-                    {props.icon.clone()}
-                </div>
-            </div>
-            <h3 class="mt-2 text-sm font-medium text-gray-900 dark:text-gray-100">
-                {&props.title}
-            </h3>
-            <p class="mt-1 text-sm text-gray-500 dark:text-gray-400">
-                {&props.description}
-            </p>
-            if let Some(action) = &props.action {
-                <div class="mt-6">
-                    {action.clone()}
-                </div>
-            }
-        </div>
-    }
-}
-
-/// Loading skeleton component
-#[function_component(UserListSkeleton)]
-pub fn user_list_skeleton() -> Html {
-    html! {
-        <div class="space-y-3 animate-pulse">
-            {(0..5).map(|_| html! {
-                <div class="bg-white dark:bg-gray-800 rounded-lg p-4">
-                    <div class="flex items-center space-x-3">
-                        <div class="w-10 h-10 bg-gray-200 dark:bg-gray-700 rounded-full"></div>
-                        <div class="flex-1">
-                            <div class="h-4 bg-gray-200 dark:bg-gray-700 rounded w-1/4 mb-2"></div>
-                            <div class="h-3 bg-gray-200 dark:bg-gray-700 rounded w-1/3"></div>
-                        </div>
-                        <div class="h-6 bg-gray-200 dark:bg-gray-700 rounded-full w-16"></div>
-                    </div>
-                </div>
-            }).collect::<Html>()}
-        </div>
-    }
-}
diff --git a/crates/frontend-daemon/src/lib.rs b/crates/frontend-daemon/src/lib.rs
deleted file mode 100644
index 94b74522..00000000
--- a/crates/frontend-daemon/src/lib.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-pub mod components;
-pub mod local_app;
-pub mod local_auth;
-pub mod onboarding;
-pub mod services;
-pub mod utils;
-
-pub use local_app::LocalApp;
-pub use local_auth::LocalAuth;
diff --git a/crates/frontend-daemon/src/local_app.rs b/crates/frontend-daemon/src/local_app.rs
deleted file mode 100644
index 15815491..00000000
--- a/crates/frontend-daemon/src/local_app.rs
+++ /dev/null
@@ -1,189 +0,0 @@
-use crate::components::{ConfigEditor, UserManagementContainer};
-use crate::local_auth::LocalAuth;
-use gate_frontend_common::{
-    auth::{use_auth, use_is_authenticated, AuthAction, AuthProvider},
-    components::{LiveChat, ThemeToggle},
-    theme::ThemeProvider,
-};
-use yew::prelude::*;
-
-#[function_component(LocalApp)]
-pub fn local_app() -> Html {
-    html! {
-        <ThemeProvider>
-            <AuthProvider>
-                <LocalAppContent />
-            </AuthProvider>
-        </ThemeProvider>
-    }
-}
-
-#[derive(Clone, Copy, PartialEq)]
-enum Tab {
-    Chat,
-    Config,
-    Users,
-}
-
-#[function_component(LocalAppContent)]
-fn local_app_content() -> Html {
-    let auth = use_auth();
-    let is_authenticated = use_is_authenticated();
-    let active_tab = use_state(|| Tab::Chat);
-    let is_admin = use_state(|| false);
-
-    let on_tab_change = {
-        let active_tab = active_tab.clone();
-        Callback::from(move |tab: Tab| {
-            active_tab.set(tab);
-        })
-    };
-
-    let on_logout = {
-        let auth = auth.clone();
-        Callback::from(move |_| {
-            auth.dispatch(AuthAction::Logout);
-        })
-    };
-
-    // For now, treat all authenticated users as having admin access
-    // TODO: In the future, check actual permissions from the backend
-    {
-        let is_admin = is_admin.clone();
-        use_effect_with(is_authenticated, move |authenticated| {
-            if *authenticated {
-                is_admin.set(true);
-            }
-            || ()
-        });
-    }
-
-    // Show loading state while auth is being restored from sessionStorage
-    if auth.is_loading {
-        html! {
-            <div class="min-h-screen bg-gray-950 flex items-center justify-center">
-                <div class="text-center">
-                    <div class="inline-flex items-center justify-center w-20 h-20 rounded-full mb-4 animate-pulse">
-                        <img src="/assets/hellas-token-white.svg" alt="Hellas" class="w-16 h-16" />
-                    </div>
-                    <p class="text-white text-lg">{"Loading..."}</p>
-                </div>
-            </div>
-        }
-    } else if is_authenticated {
-        // Show tabbed interface when authenticated
-        html! {
-            <div class="h-screen flex flex-col bg-white dark:bg-gray-900">
-                <div class="bg-gray-50 dark:bg-gray-900 border-b border-gray-200 dark:border-gray-800">
-                    <div class="p-4 flex justify-between items-center">
-                        <div class="flex items-center gap-3">
-                            <img src="/assets/Hellas_Logotype_Black.svg" class="h-6 block dark:hidden" alt="hellas" />
-                            <img src="/assets/Hellas_Logotype_White.svg" class="h-6 hidden dark:block" alt="hellas" />
-                            <span class="text-sm text-gray-500 dark:text-gray-400">{"Local Daemon"}</span>
-                        </div>
-                        <div class="flex items-center gap-3">
-                            <ThemeToggle />
-                            <button
-                                onclick={on_logout}
-                                class="px-4 py-2 text-sm font-medium text-gray-700 dark:text-gray-300 bg-gray-100 dark:bg-gray-700 hover:bg-gray-200 dark:hover:bg-gray-600 rounded-lg transition-colors flex items-center gap-2"
-                            >
-                                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M17 16l4-4m0 0l-4-4m4 4H7m6 4v1a3 3 0 01-3 3H6a3 3 0 01-3-3V7a3 3 0 013-3h4a3 3 0 013 3v1"></path>
-                                </svg>
-                                {"Logout"}
-                            </button>
-                        </div>
-                    </div>
-
-                    // Tab navigation
-                    <div class="flex">
-                        <button
-                            class={format!("px-6 py-3 text-sm font-medium transition-colors {}",
-                                if *active_tab == Tab::Chat {
-                                    "text-blue-600 dark:text-blue-400 border-b-2 border-blue-600 dark:border-blue-400"
-                                } else {
-                                    "text-gray-600 dark:text-gray-400 hover:text-gray-900 dark:hover:text-gray-100"
-                                }
-                            )}
-                            onclick={on_tab_change.reform(|_| Tab::Chat)}
-                        >
-                            <div class="flex items-center gap-2">
-                                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 12h.01M12 12h.01M16 12h.01M21 12c0 4.418-4.03 8-9 8a9.863 9.863 0 01-4.255-.949L3 20l1.395-3.72C3.512 15.042 3 13.574 3 12c0-4.418 4.03-8 9-8s9 3.582 9 8z"></path>
-                                </svg>
-                                {"Chat"}
-                            </div>
-                        </button>
-                        <button
-                            class={format!("px-6 py-3 text-sm font-medium transition-colors {}",
-                                if *active_tab == Tab::Config {
-                                    "text-blue-600 dark:text-blue-400 border-b-2 border-blue-600 dark:border-blue-400"
-                                } else {
-                                    "text-gray-600 dark:text-gray-400 hover:text-gray-900 dark:hover:text-gray-100"
-                                }
-                            )}
-                            onclick={on_tab_change.reform(|_| Tab::Config)}
-                        >
-                            <div class="flex items-center gap-2">
-                                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10.325 4.317c.426-1.756 2.924-1.756 3.35 0a1.724 1.724 0 002.573 1.066c1.543-.94 3.31.826 2.37 2.37a1.724 1.724 0 001.065 2.572c1.756.426 1.756 2.924 0 3.35a1.724 1.724 0 00-1.066 2.573c.94 1.543-.826 3.31-2.37 2.37a1.724 1.724 0 00-2.572 1.065c-.426 1.756-2.924 1.756-3.35 0a1.724 1.724 0 00-2.573-1.066c-1.543.94-3.31-.826-2.37-2.37a1.724 1.724 0 00-1.065-2.572c-1.756-.426-1.756-2.924 0-3.35a1.724 1.724 0 001.066-2.573c-.94-1.543.826-3.31 2.37-2.37.996.608 2.296.07 2.572-1.065z"></path>
-                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15 12a3 3 0 11-6 0 3 3 0 016 0z"></path>
-                                </svg>
-                                {"Config"}
-                            </div>
-                        </button>
-                        {if *is_admin {
-                            html! {
-                                <button
-                                    class={format!("px-6 py-3 text-sm font-medium transition-colors {}",
-                                        if *active_tab == Tab::Users {
-                                            "text-blue-600 dark:text-blue-400 border-b-2 border-blue-600 dark:border-blue-400"
-                                        } else {
-                                            "text-gray-600 dark:text-gray-400 hover:text-gray-900 dark:hover:text-gray-100"
-                                        }
-                                    )}
-                                    onclick={on_tab_change.reform(|_| Tab::Users)}
-                                >
-                                    <div class="flex items-center gap-2">
-                                        <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 4.354a4 4 0 110 5.292M15 21H3v-1a6 6 0 0112 0v1zm0 0h6v-1a6 6 0 00-9-5.197M13 7a4 4 0 11-8 0 4 4 0 018 0z"></path>
-                                        </svg>
-                                        {"Users"}
-                                    </div>
-                                </button>
-                            }
-                        } else {
-                            html! {}
-                        }}
-                    </div>
-                </div>
-
-                // Tab content
-                <div class="flex-1 overflow-y-auto">
-                    {match *active_tab {
-                        Tab::Chat => html! { <LiveChat /> },
-                        Tab::Config => html! { <ConfigEditor /> },
-                        Tab::Users => html! { <UserManagementContainer /> },
-                    }}
-                </div>
-            </div>
-        }
-    } else {
-        // Show minimal auth screen
-        html! {
-            <div class="min-h-screen bg-gray-950 flex items-center justify-center px-4">
-                <div class="max-w-md w-full">
-                    <div class="text-center mb-8">
-                        <div class="inline-flex items-center justify-center w-auto h-auto mb-4">
-                            <img src="/assets/Hellas_Logotype_White.svg" alt="hellas" class="w-40" />
-                        </div>
-                        <p class="text-gray-300">{"Secure AI Gateway"}</p>
-                    </div>
-                    <div class="bg-white/10 backdrop-blur-md rounded-2xl shadow-2xl p-8 border border-white/20">
-                        <LocalAuth />
-                    </div>
-                </div>
-            </div>
-        }
-    }
-}
diff --git a/crates/frontend-daemon/src/local_auth.rs b/crates/frontend-daemon/src/local_auth.rs
deleted file mode 100644
index 71256211..00000000
--- a/crates/frontend-daemon/src/local_auth.rs
+++ /dev/null
@@ -1,313 +0,0 @@
-use crate::utils::is_tauri;
-use gate_frontend_common::{
-    components::{BootstrapPrompt, Spinner as LoadingSpinner},
-    hooks::{use_webauthn, WebAuthnState},
-    services::{BootstrapService, BootstrapStatus},
-};
-use wasm_bindgen::prelude::*;
-use yew::prelude::*;
-
-#[function_component(LocalAuth)]
-pub fn local_auth() -> Html {
-    let webauthn = use_webauthn();
-
-    let name = use_state(String::new);
-    let has_tried_auto_auth = use_state(|| false);
-    let bootstrap_status = use_state(|| Option::<BootstrapStatus>::None);
-    let bootstrap_token = use_state(|| Option::<String>::None);
-    let show_bootstrap_prompt = use_state(|| false);
-    let fetched_token = use_state(|| Option::<String>::None);
-    let is_loading_token = use_state(|| false);
-
-    let bootstrap_service = use_memo((), |_| BootstrapService::new());
-
-    // Check bootstrap status on mount
-    {
-        let bootstrap_service = bootstrap_service.clone();
-        let bootstrap_status = bootstrap_status.clone();
-
-        use_effect_with((), move |_| {
-            wasm_bindgen_futures::spawn_local(async move {
-                if let Ok(status) = bootstrap_service.check_status().await {
-                    bootstrap_status.set(Some(status));
-                }
-            });
-            || ()
-        });
-    }
-
-    // Handle input changes
-    let on_name_input = {
-        let name = name.clone();
-        Callback::from(move |e: InputEvent| {
-            let input: web_sys::HtmlInputElement = e.target_unchecked_into();
-            name.set(input.value());
-        })
-    };
-
-    // Auto-trigger authentication on mount (only once)
-    {
-        let webauthn = webauthn.clone();
-        let has_tried_auto_auth = has_tried_auto_auth.clone();
-        let bootstrap_status = bootstrap_status.clone();
-
-        use_effect_with((), move |_| {
-            if !*has_tried_auto_auth {
-                has_tried_auto_auth.set(true);
-                // Only auto-authenticate if bootstrap is complete
-                if let Some(status) = (*bootstrap_status).as_ref() {
-                    if !status.needs_bootstrap {
-                        webauthn.authenticate();
-                    }
-                } else {
-                    // If we don't know bootstrap status yet, try anyway
-                    webauthn.authenticate();
-                }
-            }
-        });
-    }
-
-    // Fetch bootstrap token when needed
-    {
-        let fetched_token = fetched_token.clone();
-        let is_loading_token = is_loading_token.clone();
-        let show_bootstrap_prompt = show_bootstrap_prompt.clone();
-
-        use_effect_with(*show_bootstrap_prompt, move |show| {
-            if *show && is_tauri() {
-                is_loading_token.set(true);
-                wasm_bindgen_futures::spawn_local(async move {
-                    // Use the same fetch function from onboarding
-                    #[wasm_bindgen(inline_js = "
-                    export async function call_get_bootstrap_token_local() {
-                        try {
-                            if (window.__TAURI_INTERNALS__ && window.__TAURI_INTERNALS__.invoke) {
-                                return await window.__TAURI_INTERNALS__.invoke('get_bootstrap_token');
-                            } else if (window.__TAURI__ && window.__TAURI__.invoke) {
-                                return await window.__TAURI__.invoke('get_bootstrap_token');
-                            } else if (window.__TAURI__ && window.__TAURI__.tauri && window.__TAURI__.tauri.invoke) {
-                                return await window.__TAURI__.tauri.invoke('get_bootstrap_token');
-                            }
-                            return null;
-                        } catch (e) {
-                            console.error('Failed to get bootstrap token:', e);
-                            return null;
-                        }
-                    }
-                    ")]
-                    extern "C" {
-                        async fn call_get_bootstrap_token_local() -> JsValue;
-                    }
-
-                    let result = call_get_bootstrap_token_local().await;
-                    if result.is_string() {
-                        fetched_token.set(Some(result.as_string().unwrap()));
-                    } else if !result.is_null() {
-                        // Try to parse as JSON
-                        if let Ok(token) = serde_wasm_bindgen::from_value::<Option<String>>(result)
-                        {
-                            fetched_token.set(token);
-                        }
-                    }
-                    is_loading_token.set(false);
-                });
-            }
-            || ()
-        });
-    }
-
-    // Handle registration
-    let on_register = {
-        let webauthn = webauthn.clone();
-        let name = name.clone();
-        let bootstrap_status = bootstrap_status.clone();
-        let bootstrap_token = bootstrap_token.clone();
-        let show_bootstrap_prompt = show_bootstrap_prompt.clone();
-
-        Callback::from(move |_| {
-            let name_value = (*name).clone();
-            if !name_value.is_empty() {
-                // Check if bootstrap is needed
-                if let Some(status) = (*bootstrap_status).as_ref() {
-                    if status.needs_bootstrap && bootstrap_token.is_none() {
-                        // Show bootstrap prompt
-                        show_bootstrap_prompt.set(true);
-                        return;
-                    }
-                }
-
-                // Proceed with registration
-                webauthn.register(name_value, None, (*bootstrap_token).clone());
-            }
-        })
-    };
-
-    // Handle login
-    let on_login = {
-        let webauthn = webauthn.clone();
-        Callback::from(move |_| {
-            webauthn.authenticate();
-        })
-    };
-
-    // Clear error
-    let on_clear_error = {
-        let webauthn = webauthn.clone();
-        Callback::from(move |_| {
-            webauthn.clear_error();
-        })
-    };
-
-    // Handle bootstrap token received
-    let on_bootstrap_token = {
-        let bootstrap_token = bootstrap_token.clone();
-        let show_bootstrap_prompt = show_bootstrap_prompt.clone();
-        let webauthn = webauthn.clone();
-        let name = name.clone();
-
-        Callback::from(move |token: String| {
-            bootstrap_token.set(Some(token.clone()));
-            show_bootstrap_prompt.set(false);
-
-            // Proceed with registration
-            let name_value = (*name).clone();
-            if !name_value.is_empty() {
-                webauthn.register(name_value, None, Some(token));
-            }
-        })
-    };
-
-    html! {
-        <>
-            <BootstrapPrompt
-                show={*show_bootstrap_prompt}
-                on_token={on_bootstrap_token}
-                bootstrap_status={(*bootstrap_status).clone()}
-                bootstrap_token={(*fetched_token).clone()}
-                is_loading_token={*is_loading_token}
-            />
-
-            {match webauthn.state() {
-                WebAuthnState::Processing => {
-                    html! {
-                        <div class="text-center">
-                            <LoadingSpinner text={Some("Authenticating...".to_string())} />
-                            <p class="text-sm text-white/70 mt-4">
-                                {"Use your device's biometrics or security key"}
-                            </p>
-                        </div>
-                    }
-                }
-                WebAuthnState::Error(error) => {
-                    html! {
-                        <div class="space-y-4">
-                            <div class="bg-red-500/20 border border-red-500/30 rounded-lg p-4 text-center">
-                                <p class="text-red-200 text-sm">{error}</p>
-                            </div>
-
-                            // Show registration form if authentication failed
-                            <div class="space-y-4">
-                                <h3 class="text-white text-center font-medium">{"Create New Account"}</h3>
-
-                                {if let Some(status) = (*bootstrap_status).as_ref() {
-                                    if status.needs_bootstrap {
-                                        html! {
-                                            <div class="bg-amber-500/20 border border-amber-500/30 rounded-lg p-4 text-center mb-4">
-                                                <p class="text-amber-200 text-sm">
-                                                    {"This is the first user registration. You'll need a bootstrap token."}
-                                                </p>
-                                            </div>
-                                        }
-                                    } else {
-                                        html! {}
-                                    }
-                                } else {
-                                    html! {}
-                                }}
-
-                                <input
-                                    type="text"
-                                    class="w-full px-4 py-3 bg-white/10 border border-white/20 rounded-lg text-white placeholder-white/50 focus:outline-none focus:border-blue-400 focus:bg-white/20 transition-all"
-                                    placeholder="Enter your name"
-                                    value={(*name).clone()}
-                                    oninput={on_name_input}
-                                />
-                                <div class="flex gap-3">
-                                    <button
-                                        class="flex-1 px-4 py-3 bg-blue-600 hover:bg-blue-700 text-white rounded-lg font-medium transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
-                                        onclick={on_register}
-                                        disabled={(*name).is_empty()}
-                                    >
-                                        {"Register"}
-                                    </button>
-                                    <button
-                                        class="flex-1 px-4 py-3 bg-white/10 hover:bg-white/20 text-white rounded-lg font-medium transition-all border border-white/20"
-                                        onclick={on_clear_error}
-                                    >
-                                        {"Try Again"}
-                                    </button>
-                                </div>
-                            </div>
-                        </div>
-                    }
-                }
-                WebAuthnState::Idle => {
-                    html! {
-                        <div class="space-y-4">
-                            {if let Some(status) = (*bootstrap_status).as_ref() {
-                                if status.needs_bootstrap {
-                                    html! {
-                                        <div class="bg-blue-500/20 border border-blue-500/30 rounded-lg p-4 text-center mb-4">
-                                            <p class="text-blue-200 text-sm">
-                                                {"Welcome! This is the first time Gate is being set up."}
-                                            </p>
-                                            <p class="text-blue-200 text-sm mt-2">
-                                                {"Please register to become the administrator."}
-                                            </p>
-                                        </div>
-                                    }
-                                } else {
-                                    html! {
-                                        <p class="text-white/70 text-center text-sm">
-                                            {"No existing credentials found"}
-                                        </p>
-                                    }
-                                }
-                            } else {
-                                html! {
-                                    <p class="text-white/70 text-center text-sm">
-                                        {"No existing credentials found"}
-                                    </p>
-                                }
-                            }}
-
-                            <input
-                                type="text"
-                                class="w-full px-4 py-3 bg-white/10 border border-white/20 rounded-lg text-white placeholder-white/50 focus:outline-none focus:border-blue-400 focus:bg-white/20 transition-all"
-                                placeholder="Enter your name"
-                                value={(*name).clone()}
-                                oninput={on_name_input}
-                            />
-
-                            <div class="flex gap-3">
-                                <button
-                                    class="flex-1 px-4 py-3 bg-blue-600 hover:bg-blue-700 text-white rounded-lg font-medium transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
-                                    onclick={on_register}
-                                    disabled={(*name).is_empty()}
-                                >
-                                    {"Register New Device"}
-                                </button>
-                                <button
-                                    class="flex-1 px-4 py-3 bg-white/10 hover:bg-white/20 text-white rounded-lg font-medium transition-all border border-white/20"
-                                    onclick={on_login}
-                                >
-                                    {"Try Existing"}
-                                </button>
-                            </div>
-                        </div>
-                    }
-                }
-            }}
-        </>
-    }
-}
diff --git a/crates/frontend-daemon/src/main.rs b/crates/frontend-daemon/src/main.rs
deleted file mode 100644
index 684e2d68..00000000
--- a/crates/frontend-daemon/src/main.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-mod components;
-mod local_app;
-mod local_auth;
-mod onboarding;
-mod services;
-mod utils;
-
-use local_app::LocalApp;
-use onboarding::OnboardingAuth;
-use yew::prelude::*;
-use yew_router::prelude::*;
-
-#[derive(Clone, Routable, PartialEq)]
-enum Route {
-    #[at("/")]
-    Home,
-    #[at("/bootstrap/:token")]
-    Bootstrap { token: String },
-}
-
-fn switch(route: Route) -> Html {
-    match route {
-        Route::Home => html! { <LocalApp /> },
-        Route::Bootstrap { token } => html! {
-            <gate_frontend_common::theme::ThemeProvider>
-                <gate_frontend_common::auth::AuthProvider>
-                    <OnboardingAuth bootstrap_token={token} />
-                </gate_frontend_common::auth::AuthProvider>
-            </gate_frontend_common::theme::ThemeProvider>
-        },
-    }
-}
-
-#[function_component(App)]
-fn app() -> Html {
-    html! {
-        <BrowserRouter>
-            <Switch<Route> render={switch} />
-        </BrowserRouter>
-    }
-}
-
-fn main() {
-    wasm_logger::init(wasm_logger::Config::default());
-
-    // Initialize favicon observer for theme changes
-    utils::favicon::init_favicon_observer();
-
-    yew::Renderer::<App>::new().render();
-}
diff --git a/crates/frontend-daemon/src/onboarding.rs b/crates/frontend-daemon/src/onboarding.rs
deleted file mode 100644
index e00fc85c..00000000
--- a/crates/frontend-daemon/src/onboarding.rs
+++ /dev/null
@@ -1,152 +0,0 @@
-use gate_frontend_common::{
-    auth::use_auth,
-    components::Spinner as LoadingSpinner,
-    hooks::{use_webauthn, WebAuthnState},
-};
-use yew::prelude::*;
-
-#[derive(Properties, PartialEq)]
-pub struct OnboardingAuthProps {
-    pub bootstrap_token: String,
-}
-
-#[function_component(OnboardingAuth)]
-pub fn onboarding_auth(props: &OnboardingAuthProps) -> Html {
-    let webauthn = use_webauthn();
-    let auth = use_auth();
-    let name = use_state(String::new);
-    let bootstrap_token = props.bootstrap_token.clone();
-
-    // Redirect to home if user is authenticated
-    use_effect_with(auth.auth_state.clone(), {
-        move |auth_state| {
-            if auth_state.is_some() {
-                // User is authenticated, redirect to home
-                let window = web_sys::window().unwrap();
-                let location = window.location();
-                location.set_href("/").ok();
-            }
-        }
-    });
-
-    // Handle input changes
-    let on_name_input = {
-        let name = name.clone();
-        Callback::from(move |e: InputEvent| {
-            let input: web_sys::HtmlInputElement = e.target_unchecked_into();
-            name.set(input.value());
-        })
-    };
-
-    // Handle registration with bootstrap token
-    let on_register = {
-        let webauthn = webauthn.clone();
-        let name = name.clone();
-        let bootstrap_token = bootstrap_token.clone();
-        Callback::from(move |_| {
-            let name_value = (*name).clone();
-            web_sys::console::log_1(&format!("on_register called, name: '{name_value}'").into());
-            if !name_value.is_empty() {
-                web_sys::console::log_1(&"Calling webauthn.register".into());
-                webauthn.register(name_value, None, Some(bootstrap_token.clone()));
-            }
-        })
-    };
-
-    // Main onboarding UI
-    html! {
-        <div class="min-h-screen flex items-center justify-center bg-gray-950">
-            <div class="max-w-md w-full p-8">
-                <div class="backdrop-blur-lg bg-white/10 rounded-2xl shadow-2xl p-8 border border-white/20">
-                    <div class="text-center mb-8">
-                        <img src="/assets/Hellas_Logotype_White.svg" alt="hellas" class="w-40 mx-auto mb-4" />
-                        <p class="text-white/70">{"Let's set up your first admin account"}</p>
-                    </div>
-
-                    {match webauthn.state() {
-                        WebAuthnState::Processing => html! {
-                            <div class="text-center">
-                                <LoadingSpinner text={Some("Creating your account...".to_string())} />
-                                <p class="text-sm text-white/70 mt-4">
-                                    {"Use your device's biometrics or security key"}
-                                </p>
-                            </div>
-                        },
-                        WebAuthnState::Error(error) => html! {
-                            <div class="space-y-4">
-                                <div class="bg-red-500/20 border border-red-500/30 rounded-lg p-4 text-center">
-                                    <p class="text-red-200 text-sm">{error}</p>
-                                </div>
-                                {registration_form(&name, &on_name_input, &on_register)}
-                            </div>
-                        },
-                        WebAuthnState::Idle => html! {
-                            {registration_form(&name, &on_name_input, &on_register)}
-                        }
-                    }}
-
-                    <div class="mt-6 text-center">
-                        <p class="text-white/50 text-xs">
-                            {"This is a one-time setup. Your credentials will be securely stored."}
-                        </p>
-                    </div>
-                </div>
-            </div>
-        </div>
-    }
-}
-
-fn registration_form(
-    name: &UseStateHandle<String>,
-    on_name_input: &Callback<InputEvent>,
-    on_register: &Callback<MouseEvent>,
-) -> Html {
-    // Simple keyboard handler directly on the div
-    let handle_keydown = {
-        let name = name.clone();
-        let on_register = on_register.clone();
-        Callback::from(move |e: KeyboardEvent| {
-            web_sys::console::log_1(
-                &format!("Keydown event: key='{}', code='{}'", e.key(), e.code()).into(),
-            );
-            if e.key() == "Enter" && !(*name).is_empty() {
-                web_sys::console::log_1(
-                    &"Enter pressed with non-empty name, triggering register".into(),
-                );
-                e.prevent_default();
-                // Just emit a dummy mouse event to trigger the registration
-                let event = web_sys::MouseEvent::new("click").unwrap();
-                on_register.emit(event);
-            }
-        })
-    };
-
-    html! {
-        <div class="space-y-4">
-            <div>
-                <label class="block text-white/80 text-sm font-medium mb-2">
-                    {"Your Name"}
-                </label>
-                <input
-                    type="text"
-                    class="w-full px-4 py-3 bg-white/10 border border-white/20 rounded-lg text-white placeholder-white/50 focus:outline-none focus:border-blue-400 focus:bg-white/20 transition-all"
-                    placeholder="Enter your name"
-                    value={(**name).clone()}
-                    oninput={on_name_input}
-                    onkeydown={handle_keydown}
-                />
-                <p class="text-white/50 text-xs mt-2">
-                    {"This will be displayed when you log in"}
-                </p>
-            </div>
-
-            <button
-                class="w-full px-4 py-3 bg-blue-600 hover:bg-blue-700 text-white rounded-lg font-medium transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
-                onclick={on_register}
-                disabled={(**name).is_empty()}
-            >
-                {"Create Admin Account"}
-            </button>
-        </div>
-    }
-}
diff --git a/crates/frontend-daemon/src/services/config.rs b/crates/frontend-daemon/src/services/config.rs
deleted file mode 100644
index 17fe6ab4..00000000
--- a/crates/frontend-daemon/src/services/config.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-//! Configuration API service
-
-use gate_frontend_common::{client::ClientError, create_authenticated_client};
-use reqwest::Method;
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-
-/// Configuration API service
-#[derive(Clone)]
-pub struct ConfigApiService;
-
-impl ConfigApiService {
-    /// Create a new config API service
-    pub fn new() -> Self {
-        Self
-    }
-}
-
-impl Default for ConfigApiService {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl ConfigApiService {
-    /// Get the full configuration (requires admin authentication)
-    pub async fn get_config(&self) -> Result<Value, ClientError> {
-        let client = create_authenticated_client()?
-            .ok_or_else(|| ClientError::Configuration("Not authenticated".into()))?;
-
-        #[derive(Deserialize)]
-        struct ConfigResponse {
-            config: Value,
-        }
-
-        let response: ConfigResponse = client
-            .execute(client.request(Method::GET, "/api/config")?)
-            .await?;
-
-        Ok(response.config)
-    }
-
-    /// Update the configuration (requires admin authentication)
-    pub async fn update_config(&self, config: Value) -> Result<Value, ClientError> {
-        let client = create_authenticated_client()?
-            .ok_or_else(|| ClientError::Configuration("Not authenticated".into()))?;
-
-        #[derive(Serialize)]
-        struct UpdateRequest {
-            config: Value,
-        }
-
-        #[derive(Deserialize)]
-        struct ConfigResponse {
-            config: Value,
-        }
-
-        let response: ConfigResponse = client
-            .execute(
-                client
-                    .request(Method::PUT, "/api/config")?
-                    .json(&UpdateRequest { config }),
-            )
-            .await?;
-
-        Ok(response.config)
-    }
-}
diff --git a/crates/frontend-daemon/src/services/mod.rs b/crates/frontend-daemon/src/services/mod.rs
deleted file mode 100644
index fef5531d..00000000
--- a/crates/frontend-daemon/src/services/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-pub mod config;
-pub mod user;
-
-pub use config::ConfigApiService;
diff --git a/crates/frontend-daemon/src/services/user.rs b/crates/frontend-daemon/src/services/user.rs
deleted file mode 100644
index 771baa25..00000000
--- a/crates/frontend-daemon/src/services/user.rs
+++ /dev/null
@@ -1,216 +0,0 @@
-//! User management service
-
-use gate_frontend_common::client::{create_authenticated_client, ClientError};
-use reqwest::Method;
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct UserInfo {
-    pub id: String,
-    pub name: Option<String>,
-    pub enabled: bool,
-    pub created_at: chrono::DateTime<chrono::Utc>,
-    pub updated_at: chrono::DateTime<chrono::Utc>,
-    pub disabled_at: Option<chrono::DateTime<chrono::Utc>>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct UserListResponse {
-    pub users: Vec<UserInfo>,
-    pub total: usize,
-    pub page: usize,
-    pub page_size: usize,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct UpdateUserStatusRequest {
-    pub enabled: bool,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct UpdateUserStatusResponse {
-    pub user: UserInfo,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct UserPermission {
-    pub action: String,
-    pub object: String,
-    pub granted_at: chrono::DateTime<chrono::Utc>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct UserPermissionsResponse {
-    pub permissions: Vec<UserPermission>,
-}
-
-#[derive(Clone)]
-pub struct UserService;
-
-impl UserService {
-    pub fn new() -> Self {
-        Self
-    }
-
-    /// List all users with pagination
-    pub async fn list_users(
-        &self,
-        page: usize,
-        page_size: usize,
-        search: Option<String>,
-    ) -> Result<UserListResponse, ClientError> {
-        let client = create_authenticated_client()?
-            .ok_or_else(|| ClientError::Configuration("Not authenticated".into()))?;
-
-        let mut query_params = vec![
-            ("page", page.to_string()),
-            ("page_size", page_size.to_string()),
-        ];
-
-        if let Some(search_term) = search {
-            query_params.push(("search", search_term));
-        }
-
-        let response: UserListResponse = client
-            .execute(
-                client
-                    .request(Method::GET, "/api/admin/users")?
-                    .query(&query_params),
-            )
-            .await?;
-
-        Ok(response)
-    }
-
-    /// Get a specific user's details
-    pub async fn get_user(&self, user_id: &str) -> Result<UserInfo, ClientError> {
-        let client = create_authenticated_client()?
-            .ok_or_else(|| ClientError::Configuration("Not authenticated".into()))?;
-
-        let response: UserInfo = client
-            .execute(client.request(Method::GET, &format!("/api/admin/users/{user_id}"))?)
-            .await?;
-
-        Ok(response)
-    }
-
-    /// Update user status (enable/disable)
-    pub async fn update_user_status(
-        &self,
-        user_id: &str,
-        enabled: bool,
-    ) -> Result<UserInfo, ClientError> {
-        let client = create_authenticated_client()?
-            .ok_or_else(|| ClientError::Configuration("Not authenticated".into()))?;
-
-        let request_body = UpdateUserStatusRequest { enabled };
-
-        let response: UpdateUserStatusResponse = client
-            .execute(
-                client
-                    .request(Method::PATCH, &format!("/api/admin/users/{user_id}/status"))?
-                    .json(&request_body),
-            )
-            .await?;
-
-        Ok(response.user)
-    }
-
-    /// Delete a user
-    pub async fn delete_user(&self, user_id: &str) -> Result<(), ClientError> {
-        let client = create_authenticated_client()?
-            .ok_or_else(|| ClientError::Configuration("Not authenticated".into()))?;
-
-        // For DELETE with no response body, we expect empty JSON
-        let _: serde_json::Value = client
-            .execute(client.request(Method::DELETE, &format!("/api/admin/users/{user_id}"))?)
-            .await?;
-
-        Ok(())
-    }
-
-    /// Get user's permissions
-    pub async fn get_user_permissions(
-        &self,
-        user_id: &str,
-    ) -> Result<Vec<UserPermission>, ClientError> {
-        let client = create_authenticated_client()?
-            .ok_or_else(|| ClientError::Configuration("Not authenticated".into()))?;
-
-        let response: UserPermissionsResponse = client
-            .execute(client.request(
-                Method::GET,
-                &format!("/api/admin/users/{user_id}/permissions"),
-            )?)
-            .await?;
-
-        Ok(response.permissions)
-    }
-
-    /// Grant permission to user
-    pub async fn grant_permission(
-        &self,
-        user_id: &str,
-        action: &str,
-        object: &str,
-    ) -> Result<(), ClientError> {
-        let client = create_authenticated_client()?
-            .ok_or_else(|| ClientError::Configuration("Not authenticated".into()))?;
-
-        #[derive(Serialize)]
-        struct GrantRequest {
-            action: String,
-            object: String,
-        }
-
-        let request_body = GrantRequest {
-            action: action.to_string(),
-            object: object.to_string(),
-        };
-
-        let _: serde_json::Value = client
-            .execute(
-                client
-                    .request(
-                        Method::POST,
-                        &format!("/api/admin/users/{user_id}/permissions"),
-                    )?
-                    .json(&request_body),
-            )
-            .await?;
-
-        Ok(())
-    }
-
-    /// Revoke permission from user
-    pub async fn revoke_permission(
-        &self,
-        user_id: &str,
-        action: &str,
-        object: &str,
-    ) -> Result<(), ClientError> {
-        let client = create_authenticated_client()?
-            .ok_or_else(|| ClientError::Configuration("Not authenticated".into()))?;
-
-        let query_params = vec![("action", action), ("object", object)];
-
-        let _: serde_json::Value = client
-            .execute(
-                client
-                    .request(
-                        Method::DELETE,
-                        &format!("/api/admin/users/{user_id}/permissions"),
-                    )?
-                    .query(&query_params),
-            )
-            .await?;
-
-        Ok(())
-    }
-}
-
-impl Default for UserService {
-    fn default() -> Self {
-        Self::new()
-    }
-}
diff --git a/crates/frontend-daemon/src/utils/favicon.rs b/crates/frontend-daemon/src/utils/favicon.rs
deleted file mode 100644
index fff368c2..00000000
--- a/crates/frontend-daemon/src/utils/favicon.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use wasm_bindgen::JsCast;
-use web_sys::window;
-
-pub fn update_favicon(is_dark_mode: bool) {
-    if let Some(window) = window() {
-        if let Some(document) = window.document() {
-            // Use white icon in dark mode, black icon in light mode for better contrast
-            let favicon_path = if is_dark_mode {
-                "/assets/hellas-token-white.svg"
-            } else {
-                "/assets/hellas-token-black.svg"
-            };
-
-            // Remove existing favicon links
-            let links = document.query_selector_all("link[rel*='icon']").unwrap();
-            for i in 0..links.length() {
-                if let Some(link) = links.item(i) {
-                    if let Ok(element) = link.dyn_into::<web_sys::Element>() {
-                        element.remove();
-                    }
-                }
-            }
-
-            // Create new favicon link
-            if let Some(head) = document.head() {
-                if let Ok(link) = document.create_element("link") {
-                    let link = link.dyn_into::<web_sys::HtmlLinkElement>().unwrap();
-                    link.set_rel("icon");
-                    link.set_type("image/svg+xml");
-                    link.set_href(favicon_path);
-                    let _ = head.append_child(&link);
-                }
-            }
-        }
-    }
-}
-
-pub fn init_favicon_observer() {
-    // Check for theme on initial load
-    let is_dark = is_dark_mode();
-    update_favicon(is_dark);
-
-    // Watch for theme changes via class on html element
-    if let Some(window) = window() {
-        use wasm_bindgen::closure::Closure;
-
-        let callback = Closure::wrap(Box::new(move || {
-            let is_dark = is_dark_mode();
-            update_favicon(is_dark);
-        }) as Box<dyn Fn()>);
-
-        // Use a simple interval as MutationObserver is complex in wasm
-        let _ = window.set_interval_with_callback_and_timeout_and_arguments_0(
-            callback.as_ref().unchecked_ref(),
-            1000, // Check every second
-        );
-        callback.forget();
-    }
-}
-
-fn is_dark_mode() -> bool {
-    if let Some(window) = window() {
-        if let Some(document) = window.document() {
-            if let Some(html_element) = document.document_element() {
-                return html_element.class_list().contains("dark");
-            }
-        }
-    }
-    false
-}
diff --git a/crates/frontend-daemon/src/utils/mod.rs b/crates/frontend-daemon/src/utils/mod.rs
deleted file mode 100644
index 065ceaac..00000000
--- a/crates/frontend-daemon/src/utils/mod.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-pub mod favicon;
-
-use wasm_bindgen::prelude::*;
-
-#[wasm_bindgen(inline_js = "
-export function is_tauri_context() {
-    return typeof window !== 'undefined' && window.__TAURI__ !== undefined;
-}
-")]
-extern "C" {
-    #[wasm_bindgen(js_name = is_tauri_context)]
-    pub fn is_tauri() -> bool;
-}
diff --git a/crates/frontend-daemon/style.css b/crates/frontend-daemon/style.css
deleted file mode 100644
index 0b6ba495..00000000
--- a/crates/frontend-daemon/style.css
+++ /dev/null
@@ -1,59 +0,0 @@
-@import "tailwindcss";
-@config "./tailwind.config.js";
-@source "index.html";
-@source "src/**/*.rs";
-@source "../frontend-common/src/**/*.rs";
-@source "../chat-ui/src/**/*.rs";
-
-@theme {
-  --color-gray-50: #f9fafb;
-  --color-gray-100: #f3f4f6;
-  --color-gray-200: #e5e7eb;
-  --color-gray-300: #d1d5db;
-  --color-gray-400: #9ca3af;
-  --color-gray-500: #6b7280;
-  --color-gray-600: #4b5563;
-  --color-gray-700: #374151;
-  --color-gray-800: #1f2937;
-  --color-gray-900: #111827;
-  --color-blue-50: #eff6ff;
-  --color-blue-100: #dbeafe;
-  --color-blue-200: #bfdbfe;
-  --color-blue-300: #93c5fd;
-  --color-blue-400: #60a5fa;
-  --color-blue-500: #3b82f6;
-  --color-blue-600: #2563eb;
-  --color-blue-700: #1d4ed8;
-  --color-blue-800: #1e40af;
-  --color-blue-900: #1e3a8a;
-  --color-purple-500: #8b5cf6;
-  --color-purple-600: #7c3aed;
-  --color-purple-900: #581c87;
-  --color-green-50: #f0fdf4;
-  --color-green-100: #dcfce7;
-  --color-green-200: #bbf7d0;
-  --color-green-400: #4ade80;
-  --color-green-600: #16a34a;
-  --color-green-700: #15803d;
-  --color-green-800: #166534;
-  --color-green-900: #14532d;
-  --color-red-50: #fef2f2;
-  --color-red-100: #fee2e2;
-  --color-red-200: #fecaca;
-  --color-red-400: #f87171;
-  --color-red-500: #ef4444;
-  --color-red-600: #dc2626;
-  --color-red-700: #b91c1c;
-  --color-red-800: #991b1b;
-  --color-red-900: #7f1d1d;
-  --color-orange-50: #fff7ed;
-  --color-orange-100: #ffedd5;
-  --color-orange-200: #fed7aa;
-  --color-orange-800: #9a3412;
-  --color-amber-50: #fffbeb;
-  --color-amber-200: #fde68a;
-  --color-amber-800: #92400e;
-  --color-yellow-500: #eab308;
-  --color-white: #ffffff;
-  --color-black: #000000;
-}
diff --git a/crates/frontend-daemon/tailwind.config.js b/crates/frontend-daemon/tailwind.config.js
deleted file mode 100644
index b3200035..00000000
--- a/crates/frontend-daemon/tailwind.config.js
+++ /dev/null
@@ -1,30 +0,0 @@
-module.exports = {
-  darkMode: 'class',
-  content: [
-    "./index.html",
-    "./src/**/*.{rs,html}",
-    "../frontend-common/src/**/*.rs",
-    "../chat-ui/src/**/*.rs",
-  ],
-  theme: {
-    extend: {
-      animation: {
-        'spin': 'spin 1s linear infinite',
-        'pulse-dot': 'pulse-dot 1.4s ease-in-out infinite',
-      },
-      keyframes: {
-        'pulse-dot': {
-          '0%, 80%, 100%': {
-            opacity: '0.3',
-            transform: 'scale(0.8)',
-          },
-          '40%': {
-            opacity: '1',
-            transform: 'scale(1)',
-          },
-        },
-      },
-    },
-  },
-  plugins: [],
-}
\ No newline at end of file
diff --git a/crates/frontend-relay/.gitignore b/crates/frontend-relay/.gitignore
deleted file mode 100644
index b5dd7e48..00000000
--- a/crates/frontend-relay/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-dist/
-tailwind.output.css
diff --git a/crates/frontend-relay/Cargo.toml b/crates/frontend-relay/Cargo.toml
deleted file mode 100644
index 5013eeed..00000000
--- a/crates/frontend-relay/Cargo.toml
+++ /dev/null
@@ -1,26 +0,0 @@
-[package]
-name = "gate-frontend-relay"
-version = "0.1.0"
-edition = "2021"
-authors = ["Hellas AI"]
-license = "AGPL-3.0"
-description = "Relay web UI frontend for Gate"
-
-[dependencies]
-gate-frontend-common = { path = "../frontend-common" }
-yew = { workspace = true, features = ["csr"] }
-yew-router = { workspace = true }
-web-sys = { workspace = true }
-wasm-bindgen = { workspace = true }
-wasm-bindgen-futures = { workspace = true }
-wasm-logger = { workspace = true }
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
-tracing = "0.1"
-tracing-subscriber = { version = "0.3", features = ["fmt"] }
-tracing-web = { workspace = true }
-gloo-timers = { workspace = true }
-gloo-net = { workspace = true, features = ["http", "json"] }
-
-[dev-dependencies]
-wasm-bindgen-test = { workspace = true }
\ No newline at end of file
diff --git a/crates/frontend-relay/Trunk.toml b/crates/frontend-relay/Trunk.toml
deleted file mode 100644
index f3dbfe80..00000000
--- a/crates/frontend-relay/Trunk.toml
+++ /dev/null
@@ -1,25 +0,0 @@
-[[proxy]]
-rewrite = "/auth/"
-backend = "http://localhost:3000/auth/"
-
-[[proxy]]
-rewrite = "/health"
-backend = "http://localhost:3000/health"
-
-[[proxy]]
-rewrite = "/v1/"
-backend = "http://localhost:3000/v1/"
-
-[build]
-target = "index.html"
-dist = "dist"
-
-[[hooks]]
-stage = "pre_build"
-command = "tailwindcss"
-command_arguments = ["-i", "./style.css", "-o", "./tailwind.output.css", "--minify"]
-
-[serve]
-addresses = ["127.0.0.1"]
-port = 8081
-open = false
\ No newline at end of file
diff --git a/crates/frontend-relay/index.html b/crates/frontend-relay/index.html
deleted file mode 100644
index a52bcd4e..00000000
--- a/crates/frontend-relay/index.html
+++ /dev/null
@@ -1,12 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>Gate Frontend</title>
-    <link data-trunk rel="css" href="tailwind.output.css" />
-</head>
-<body class="bg-white dark:bg-gray-900">
-    <div id="app"></div>
-</body>
-</html>
\ No newline at end of file
diff --git a/crates/frontend-relay/src/app.rs b/crates/frontend-relay/src/app.rs
deleted file mode 100644
index 90257104..00000000
--- a/crates/frontend-relay/src/app.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-use crate::components::NodesList;
-use gate_frontend_common::{components::ThemeToggle, theme::ThemeProvider};
-use yew::prelude::*;
-
-#[function_component(RelayApp)]
-pub fn relay_app() -> Html {
-    html! {
-        <ThemeProvider>
-            <RelayAppContent />
-        </ThemeProvider>
-    }
-}
-
-#[function_component(RelayAppContent)]
-fn relay_app_content() -> Html {
-    html! {
-        <div class="h-screen w-screen flex flex-col bg-gray-50 dark:bg-gray-900">
-            <header class="flex items-center justify-between p-4 bg-white dark:bg-gray-800 shadow-sm">
-                <h1 class="text-2xl font-bold text-gray-900 dark:text-white">{"Gate Relay"}</h1>
-                <div class="flex items-center gap-4">
-                    <ThemeToggle />
-                </div>
-            </header>
-            <main class="flex-1 p-6 overflow-y-auto">
-                <div class="max-w-6xl mx-auto space-y-6">
-                    <div class="bg-white dark:bg-gray-800 rounded-lg shadow p-6">
-                        <h2 class="text-xl font-semibold mb-4 text-gray-900 dark:text-white">{"TLS Forward Server Status"}</h2>
-                        <div class="grid grid-cols-1 md:grid-cols-3 gap-4">
-                            <div class="bg-gray-50 dark:bg-gray-900 rounded p-4">
-                                <p class="text-sm text-gray-600 dark:text-gray-400">{"Status"}</p>
-                                <p class="text-lg font-semibold text-green-600 dark:text-green-400">{"Online"}</p>
-                            </div>
-                            <div class="bg-gray-50 dark:bg-gray-900 rounded p-4">
-                                <p class="text-sm text-gray-600 dark:text-gray-400">{"Domain Suffix"}</p>
-                                <p class="text-lg font-semibold text-gray-900 dark:text-white">{"private.hellas.ai"}</p>
-                            </div>
-                            <div class="bg-gray-50 dark:bg-gray-900 rounded p-4">
-                                <p class="text-sm text-gray-600 dark:text-gray-400">{"HTTPS Proxy"}</p>
-                                <p class="text-lg font-semibold text-gray-900 dark:text-white">{"443"}</p>
-                            </div>
-                        </div>
-                    </div>
-
-                    <NodesList />
-                </div>
-            </main>
-        </div>
-    }
-}
diff --git a/crates/frontend-relay/src/components/mod.rs b/crates/frontend-relay/src/components/mod.rs
deleted file mode 100644
index eeb28621..00000000
--- a/crates/frontend-relay/src/components/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-pub mod nodes_list;
-
-pub use nodes_list::NodesList;
diff --git a/crates/frontend-relay/src/components/nodes_list.rs b/crates/frontend-relay/src/components/nodes_list.rs
deleted file mode 100644
index 4f7a403e..00000000
--- a/crates/frontend-relay/src/components/nodes_list.rs
+++ /dev/null
@@ -1,248 +0,0 @@
-use serde::{Deserialize, Serialize};
-use wasm_bindgen_futures::spawn_local;
-use web_sys::window;
-use yew::prelude::*;
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct ConnectedNode {
-    pub node_id: String,
-    pub domain: String,
-    pub connected_at: String,
-    pub uptime_seconds: u64,
-    pub latency_ms: Option<u64>,
-    pub last_ping: String,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct ListNodesResponse {
-    pub nodes: Vec<ConnectedNode>,
-    pub total: usize,
-}
-
-pub enum Msg {
-    FetchNodes,
-    NodesReceived(Result<ListNodesResponse, String>),
-}
-
-pub struct NodesList {
-    nodes: Vec<ConnectedNode>,
-    loading: bool,
-    error: Option<String>,
-    _interval: Option<gloo_timers::callback::Interval>,
-}
-
-impl Component for NodesList {
-    type Message = Msg;
-    type Properties = ();
-
-    fn create(ctx: &Context<Self>) -> Self {
-        // Fetch nodes immediately
-        ctx.link().send_message(Msg::FetchNodes);
-
-        // Set up auto-refresh every 5 seconds
-        let link = ctx.link().clone();
-        let interval = gloo_timers::callback::Interval::new(5000, move || {
-            link.send_message(Msg::FetchNodes);
-        });
-
-        Self {
-            nodes: vec![],
-            loading: true,
-            error: None,
-            _interval: Some(interval),
-        }
-    }
-
-    fn update(&mut self, _ctx: &Context<Self>, msg: Self::Message) -> bool {
-        match msg {
-            Msg::FetchNodes => {
-                self.loading = true;
-                let link = _ctx.link().clone();
-
-                spawn_local(async move {
-                    let result = fetch_nodes().await;
-                    link.send_message(Msg::NodesReceived(result));
-                });
-
-                false
-            }
-            Msg::NodesReceived(result) => {
-                self.loading = false;
-                match result {
-                    Ok(response) => {
-                        self.nodes = response.nodes;
-                        self.error = None;
-                    }
-                    Err(e) => {
-                        self.error = Some(e);
-                    }
-                }
-                true
-            }
-        }
-    }
-
-    fn view(&self, _ctx: &Context<Self>) -> Html {
-        html! {
-            <div class="bg-white dark:bg-gray-800 rounded-lg shadow">
-                <div class="px-6 py-4 border-b border-gray-200 dark:border-gray-700">
-                    <h3 class="text-lg font-semibold text-gray-900 dark:text-white">
-                        {"Connected Nodes"}
-                        if !self.nodes.is_empty() {
-                            <span class="ml-2 text-sm font-normal text-gray-500 dark:text-gray-400">
-                                {format!("({} total)", self.nodes.len())}
-                            </span>
-                        }
-                    </h3>
-                </div>
-
-                <div class="p-6">
-                    {if self.loading && self.nodes.is_empty() {
-                        html! {
-                            <div class="text-center py-8">
-                                <div class="inline-flex items-center">
-                                    <svg class="animate-spin h-5 w-5 mr-2 text-blue-600" 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>
-                                    <span class="text-gray-600 dark:text-gray-400">{"Loading nodes..."}</span>
-                                </div>
-                            </div>
-                        }
-                    } else if let Some(error) = &self.error {
-                        html! {
-                            <div class="text-center py-8">
-                                <p class="text-red-600 dark:text-red-400">{format!("Error: {}", error)}</p>
-                            </div>
-                        }
-                    } else if self.nodes.is_empty() {
-                        html! {
-                            <div class="text-center py-8">
-                                <p class="text-gray-500 dark:text-gray-400">{"No nodes connected"}</p>
-                            </div>
-                        }
-                    } else {
-                        html! {
-                            <div class="overflow-x-auto">
-                                <table class="min-w-full divide-y divide-gray-200 dark:divide-gray-700">
-                                    <thead>
-                                        <tr>
-                                            <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider">
-                                                {"Node ID"}
-                                            </th>
-                                            <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider">
-                                                {"Domain"}
-                                            </th>
-                                            <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider">
-                                                {"Uptime"}
-                                            </th>
-                                            <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider">
-                                                {"Latency"}
-                                            </th>
-                                            <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider">
-                                                {"Status"}
-                                            </th>
-                                        </tr>
-                                    </thead>
-                                    <tbody class="divide-y divide-gray-200 dark:divide-gray-700">
-                                        {for self.nodes.iter().map(|node| self.view_node(node))}
-                                    </tbody>
-                                </table>
-                            </div>
-                        }
-                    }}
-                </div>
-            </div>
-        }
-    }
-}
-
-impl NodesList {
-    fn view_node(&self, node: &ConnectedNode) -> Html {
-        let short_id = &node.node_id[..10.min(node.node_id.len())];
-        let uptime = format_duration(node.uptime_seconds);
-        let latency = node
-            .latency_ms
-            .map(|ms| format!("{ms} ms"))
-            .unwrap_or_else(|| "N/A".to_string());
-
-        html! {
-            <tr class="hover:bg-gray-50 dark:hover:bg-gray-750">
-                <td class="px-4 py-3 whitespace-nowrap">
-                    <div class="flex items-center">
-                        <div class="text-sm">
-                            <div class="font-medium text-gray-900 dark:text-white font-mono">
-                                {short_id}{"..."}
-                            </div>
-                            <div class="text-xs text-gray-500 dark:text-gray-400 font-mono">
-                                {&node.node_id}
-                            </div>
-                        </div>
-                    </div>
-                </td>
-                <td class="px-4 py-3 whitespace-nowrap">
-                    <a href={format!("https://{}", node.domain)}
-                       target="_blank"
-                       class="text-blue-600 dark:text-blue-400 hover:underline text-sm">
-                        {&node.domain}
-                    </a>
-                </td>
-                <td class="px-4 py-3 whitespace-nowrap text-sm text-gray-900 dark:text-white">
-                    {uptime}
-                </td>
-                <td class="px-4 py-3 whitespace-nowrap text-sm text-gray-900 dark:text-white">
-                    {latency}
-                </td>
-                <td class="px-4 py-3 whitespace-nowrap">
-                    <span class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200">
-                        {"Connected"}
-                    </span>
-                </td>
-            </tr>
-        }
-    }
-}
-
-fn format_duration(seconds: u64) -> String {
-    let days = seconds / 86400;
-    let hours = (seconds % 86400) / 3600;
-    let minutes = (seconds % 3600) / 60;
-    let secs = seconds % 60;
-
-    if days > 0 {
-        format!("{days}d {hours}h")
-    } else if hours > 0 {
-        format!("{hours}h {minutes}m")
-    } else if minutes > 0 {
-        format!("{minutes}m {secs}s")
-    } else {
-        format!("{secs}s")
-    }
-}
-
-async fn fetch_nodes() -> Result<ListNodesResponse, String> {
-    let window = window().ok_or("No window object")?;
-    let location = window.location();
-
-    // Get the base URL
-    let protocol = location.protocol().map_err(|_| "Failed to get protocol")?;
-    let host = location.host().map_err(|_| "Failed to get host")?;
-    let base_url = format!("{protocol}//{host}");
-
-    // Make request to /nodes endpoint
-    let url = format!("{base_url}/nodes");
-
-    let response = gloo_net::http::Request::get(&url)
-        .send()
-        .await
-        .map_err(|e| format!("Network error: {e}"))?;
-
-    if !response.ok() {
-        return Err(format!("Server error: {}", response.status()));
-    }
-
-    response
-        .json::<ListNodesResponse>()
-        .await
-        .map_err(|e| format!("Failed to parse response: {e}"))
-}
diff --git a/crates/frontend-relay/src/lib.rs b/crates/frontend-relay/src/lib.rs
deleted file mode 100644
index fc97ca3e..00000000
--- a/crates/frontend-relay/src/lib.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-pub mod app;
-pub mod components;
-
-pub use app::RelayApp;
diff --git a/crates/frontend-relay/src/main.rs b/crates/frontend-relay/src/main.rs
deleted file mode 100644
index 4b76c4ba..00000000
--- a/crates/frontend-relay/src/main.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-use gate_frontend_relay::RelayApp;
-
-fn main() {
-    wasm_logger::init(wasm_logger::Config::default());
-    yew::Renderer::<RelayApp>::new().render();
-}
diff --git a/crates/frontend-relay/style.css b/crates/frontend-relay/style.css
deleted file mode 100644
index 352f96ea..00000000
--- a/crates/frontend-relay/style.css
+++ /dev/null
@@ -1,6 +0,0 @@
-@import "tailwindcss";
-@config "./tailwind.config.js";
-@source "index.html";
-@source "src/**/*.rs";
-@source "../frontend-common/src/**/*.rs";
-@source "../chat-ui/src/**/*.rs";
diff --git a/crates/frontend-relay/tailwind.config.js b/crates/frontend-relay/tailwind.config.js
deleted file mode 100644
index b3200035..00000000
--- a/crates/frontend-relay/tailwind.config.js
+++ /dev/null
@@ -1,30 +0,0 @@
-module.exports = {
-  darkMode: 'class',
-  content: [
-    "./index.html",
-    "./src/**/*.{rs,html}",
-    "../frontend-common/src/**/*.rs",
-    "../chat-ui/src/**/*.rs",
-  ],
-  theme: {
-    extend: {
-      animation: {
-        'spin': 'spin 1s linear infinite',
-        'pulse-dot': 'pulse-dot 1.4s ease-in-out infinite',
-      },
-      keyframes: {
-        'pulse-dot': {
-          '0%, 80%, 100%': {
-            opacity: '0.3',
-            transform: 'scale(0.8)',
-          },
-          '40%': {
-            opacity: '1',
-            transform: 'scale(1)',
-          },
-        },
-      },
-    },
-  },
-  plugins: [],
-}
\ No newline at end of file
diff --git a/crates/frontend-tauri/.gitignore b/crates/frontend-tauri/.gitignore
deleted file mode 100644
index b5dd7e48..00000000
--- a/crates/frontend-tauri/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-dist/
-tailwind.output.css
diff --git a/crates/frontend-tauri/Cargo.toml b/crates/frontend-tauri/Cargo.toml
deleted file mode 100644
index 2420134c..00000000
--- a/crates/frontend-tauri/Cargo.toml
+++ /dev/null
@@ -1,33 +0,0 @@
-[package]
-name = "gate-frontend-tauri"
-version = "0.1.0"
-edition = "2021"
-authors = ["Hellas AI"]
-license = "AGPL-3.0"
-description = "Tauri desktop app frontend for Gate"
-
-[dependencies]
-gate-frontend-common = { path = "../frontend-common" }
-gate-chat-ui = { path = "../chat-ui" }
-yew = { workspace = true, features = ["csr"] }
-yew-router = { workspace = true }
-web-sys = { workspace = true, features = ["Navigator", "Clipboard", "Window", "Document", "Element", "HtmlElement", "Location", "MediaQueryList", "MediaQueryListEvent"] }
-wasm-bindgen = { workspace = true }
-wasm-bindgen-futures = { workspace = true }
-js-sys = { workspace = true }
-wasm-logger = { workspace = true }
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
-serde-wasm-bindgen = { workspace = true }
-tracing = "0.1"
-tracing-subscriber = { version = "0.3", features = ["fmt"] }
-tracing-web = { workspace = true }
-gloo-timers = { workspace = true }
-gloo-utils = { workspace = true }
-gloo-events = { workspace = true }
-
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-getrandom = { workspace = true, features = ["wasm_js"] }
-
-[dev-dependencies]
-wasm-bindgen-test = { workspace = true }
diff --git a/crates/frontend-tauri/Trunk.toml b/crates/frontend-tauri/Trunk.toml
deleted file mode 100644
index 398fbdb4..00000000
--- a/crates/frontend-tauri/Trunk.toml
+++ /dev/null
@@ -1,17 +0,0 @@
-[[proxy]]
-rewrite = "/api/"
-backend = "http://localhost:31145/"
-
-[build]
-target = "index.html"
-dist = "dist"
-
-[[hooks]]
-stage = "pre_build"
-command = "tailwindcss"
-command_arguments = ["-i", "./style.css", "-o", "./tailwind.output.css", "--minify"]
-
-[serve]
-addresses = ["127.0.0.1"]
-port = 8082
-open = false
\ No newline at end of file
diff --git a/crates/frontend-tauri/index.html b/crates/frontend-tauri/index.html
deleted file mode 100644
index a52bcd4e..00000000
--- a/crates/frontend-tauri/index.html
+++ /dev/null
@@ -1,12 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>Gate Frontend</title>
-    <link data-trunk rel="css" href="tailwind.output.css" />
-</head>
-<body class="bg-white dark:bg-gray-900">
-    <div id="app"></div>
-</body>
-</html>
\ No newline at end of file
diff --git a/crates/frontend-tauri/src/app.rs b/crates/frontend-tauri/src/app.rs
deleted file mode 100644
index da74c51e..00000000
--- a/crates/frontend-tauri/src/app.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-use crate::components::DaemonStatusComponent;
-use gloo_utils::window;
-use wasm_bindgen::JsCast;
-use yew::prelude::*;
-
-#[function_component(TauriApp)]
-pub fn tauri_app() -> Html {
-    let is_dark = use_state(|| {
-        window()
-            .match_media("(prefers-color-scheme: dark)")
-            .ok()
-            .flatten()
-            .map(|m| m.matches())
-            .unwrap_or(true)
-    });
-
-    use_effect_with((), {
-        let is_dark = is_dark.clone();
-        move |_| {
-            let is_dark = is_dark.clone();
-            if let Ok(Some(media_query)) = window().match_media("(prefers-color-scheme: dark)") {
-                let listener = gloo_events::EventListener::new(&media_query, "change", move |e| {
-                    if let Some(event) = e.dyn_ref::<web_sys::MediaQueryListEvent>() {
-                        is_dark.set(event.matches());
-                    }
-                });
-                // Keep the listener alive
-                listener.forget();
-            }
-        }
-    });
-
-    html! {
-        <div class={classes!(
-            "h-screen", "w-screen", "font-sans", "transition-colors", "duration-300",
-            "bg-gradient-to-br", "from-gray-900", "via-blue-900", "to-purple-900"
-        )}>
-            <div class="h-full w-full p-8 overflow-y-auto backdrop-blur-lg bg-white/10 rounded-2xl shadow-2xl border border-white/20">
-                <div class="text-center mb-8">
-                    <h1 class="text-3xl font-bold text-white mb-2">{"Hellas Gate"}</h1>
-                </div>
-                <DaemonStatusComponent is_dark={true} />
-            </div>
-        </div>
-    }
-}
diff --git a/crates/frontend-tauri/src/components/daemon_status.rs b/crates/frontend-tauri/src/components/daemon_status.rs
deleted file mode 100644
index 7cd0c76e..00000000
--- a/crates/frontend-tauri/src/components/daemon_status.rs
+++ /dev/null
@@ -1,675 +0,0 @@
-use crate::tauri_api::{
-    configure_tlsforward, enable_tlsforward, get_daemon_runtime_config, get_daemon_status,
-    start_daemon, DaemonRuntimeConfig, Settings, TlsForwardState,
-};
-use gloo_timers::callback::Interval;
-use wasm_bindgen::JsCast;
-use wasm_bindgen_futures::spawn_local;
-use web_sys::InputEvent;
-use yew::prelude::*;
-
-#[derive(Properties, PartialEq)]
-pub struct DaemonStatusProps {
-    #[prop_or(true)]
-    pub is_dark: bool,
-}
-
-pub struct DaemonStatusComponent {
-    is_running: bool,
-    listen_address: Option<String>,
-    has_providers: bool,
-    runtime_config: Option<DaemonRuntimeConfig>,
-    error_message: Option<String>,
-    debug_messages: Vec<String>,
-    _poll_interval: Option<Interval>,
-    show_tlsforward_form: bool,
-    tlsforward_email: String,
-    tlsforward_loading: bool,
-    initial_connect_attempts: u32,
-    poll_delay_ms: u32,
-    show_debug_log: bool,
-    needs_email_setup: bool,
-    daemon_config: Option<Settings>,
-}
-
-pub enum Msg {
-    UpdateStatus(bool, Option<String>, bool),
-    UpdateConfig(DaemonRuntimeConfig),
-    UpdateDaemonConfig(Settings),
-    Refresh,
-    StartDaemon,
-    SetError(String),
-    AddDebugMessage(String),
-    ShowTlsForwardForm,
-    HideTlsForwardForm,
-    UpdateTlsForwardEmail(String),
-    ConfigureTlsForward,
-    TlsForwardConfigured,
-    ToggleDebugLog,
-    OpenUrl(String),
-}
-
-impl Component for DaemonStatusComponent {
-    type Message = Msg;
-    type Properties = DaemonStatusProps;
-
-    fn create(ctx: &Context<Self>) -> Self {
-        // Add initial debug message about window location
-        ctx.link().send_message(Msg::AddDebugMessage(format!(
-            "Window location: {}",
-            web_sys::window()
-                .unwrap()
-                .location()
-                .href()
-                .unwrap_or_default()
-        )));
-
-        // Start with faster polling for initial connection
-        let component = Self {
-            is_running: false,
-            listen_address: None,
-            has_providers: false,
-            runtime_config: None,
-            error_message: None,
-            debug_messages: vec![],
-            _poll_interval: None,
-            show_tlsforward_form: false,
-            tlsforward_email: String::new(),
-            tlsforward_loading: false,
-            initial_connect_attempts: 0,
-            poll_delay_ms: 1, // Start with 1ms polling
-            show_debug_log: false,
-            needs_email_setup: false,
-            daemon_config: None,
-        };
-
-        // Fetch initial status immediately
-        ctx.link().send_message(Msg::Refresh);
-
-        component
-    }
-
-    fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
-        match msg {
-            Msg::UpdateStatus(running, address, providers) => {
-                self.is_running = running;
-                self.listen_address = address;
-                self.has_providers = providers;
-                true
-            }
-            Msg::UpdateConfig(config) => {
-                self.runtime_config = Some(config);
-                true
-            }
-            Msg::UpdateDaemonConfig(config) => {
-                // Check if we need email setup
-                self.needs_email_setup = config.letsencrypt.email.is_none();
-                self.daemon_config = Some(config);
-                true
-            }
-            Msg::Refresh => {
-                let link = ctx.link().clone();
-
-                spawn_local(async move {
-                    // Get daemon status
-                    match get_daemon_status().await {
-                        Ok(status) => {
-                            link.send_message(Msg::UpdateStatus(
-                                status.running,
-                                status.listen_address,
-                                status.has_providers,
-                            ));
-
-                            // If running, get config too
-                            if status.running {
-                                match get_daemon_runtime_config().await {
-                                    Ok(config) => {
-                                        link.send_message(Msg::UpdateConfig(config));
-                                    }
-                                    Err(_) => {
-                                        // Silent error during polling
-                                    }
-                                }
-
-                                // Also get daemon config to check for email
-                                match crate::tauri_api::get_daemon_config().await {
-                                    Ok(config) => {
-                                        link.send_message(Msg::UpdateDaemonConfig(config));
-                                    }
-                                    Err(_) => {
-                                        // Silent error
-                                    }
-                                }
-                            }
-                        }
-                        Err(_) => {
-                            // Silent error during polling - daemon might be starting
-                        }
-                    }
-                });
-
-                // Schedule next poll with exponential backoff
-                if !self.is_running {
-                    self.initial_connect_attempts += 1;
-
-                    // Exponential backoff: 1ms -> 5ms -> 25ms -> 125ms -> 500ms -> 2000ms
-                    if self.poll_delay_ms < 2000 {
-                        self.poll_delay_ms = match self.poll_delay_ms {
-                            1 => 5,
-                            5 => 25,
-                            25 => 125,
-                            125 => 200,
-                            200 => 500,
-                            _ => 500,
-                        };
-                    }
-                } else {
-                    self.poll_delay_ms = 500;
-                }
-
-                // Set up next poll
-                self._poll_interval = None;
-                let link = ctx.link().clone();
-                let interval = Interval::new(self.poll_delay_ms, move || {
-                    link.send_message(Msg::Refresh);
-                });
-                self._poll_interval = Some(interval);
-
-                false
-            }
-            Msg::StartDaemon => {
-                web_sys::console::log_1(&"Starting daemon...".into());
-                ctx.link()
-                    .send_message(Msg::AddDebugMessage("Starting daemon...".to_string()));
-                let link = ctx.link().clone();
-                spawn_local(async move {
-                    // Start daemon
-                    match start_daemon().await {
-                        Ok(msg) => {
-                            web_sys::console::log_1(&format!("Daemon started: {msg}").into());
-                            link.send_message(Msg::AddDebugMessage(format!(
-                                "Daemon started: {msg}"
-                            )));
-                            // Refresh status after starting
-                            link.send_message(Msg::Refresh);
-                        }
-                        Err(e) => {
-                            web_sys::console::error_1(
-                                &format!("Failed to start daemon: {e}").into(),
-                            );
-                            link.send_message(Msg::SetError(format!(
-                                "Failed to start daemon: {e}"
-                            )));
-                        }
-                    }
-                });
-                false
-            }
-            Msg::SetError(error) => {
-                self.error_message = Some(error);
-                true
-            }
-            Msg::AddDebugMessage(msg) => {
-                self.debug_messages.push(msg);
-                if self.debug_messages.len() > 10 {
-                    self.debug_messages.remove(0);
-                }
-                true
-            }
-            Msg::ShowTlsForwardForm => {
-                self.show_tlsforward_form = true;
-                true
-            }
-            Msg::HideTlsForwardForm => {
-                self.show_tlsforward_form = false;
-                self.tlsforward_email.clear();
-                true
-            }
-            Msg::UpdateTlsForwardEmail(email) => {
-                self.tlsforward_email = email;
-                true
-            }
-            Msg::ConfigureTlsForward => {
-                if self.tlsforward_email.contains('@') && self.tlsforward_email.len() > 3 {
-                    self.tlsforward_loading = true;
-                    let email = self.tlsforward_email.clone();
-                    let link = ctx.link().clone();
-                    spawn_local(async move {
-                        match configure_tlsforward(email).await {
-                            Ok(_) => {
-                                match enable_tlsforward().await {
-                                    Ok(_) => {
-                                        link.send_message(Msg::TlsForwardConfigured);
-                                        link.send_message(Msg::HideTlsForwardForm);
-                                        // Refresh to get new status
-                                        link.send_message(Msg::Refresh);
-                                    }
-                                    Err(e) => {
-                                        link.send_message(Msg::SetError(format!(
-                                            "Failed to enable TLS forward: {e}"
-                                        )));
-                                    }
-                                }
-                            }
-                            Err(e) => {
-                                link.send_message(Msg::SetError(format!(
-                                    "Failed to configure: {e}"
-                                )));
-                            }
-                        }
-                    });
-                } else {
-                    self.error_message = Some("Please enter a valid email address".to_string());
-                }
-                true
-            }
-            Msg::TlsForwardConfigured => {
-                self.tlsforward_loading = false;
-                true
-            }
-            Msg::ToggleDebugLog => {
-                web_sys::console::log_1(
-                    &format!(
-                        "Debug button clicked! Current state: {}, New state: {}",
-                        self.show_debug_log, !self.show_debug_log
-                    )
-                    .into(),
-                );
-                self.show_debug_log = !self.show_debug_log;
-                ctx.link().send_message(Msg::AddDebugMessage(format!(
-                    "Debug log toggled to: {}",
-                    self.show_debug_log
-                )));
-                true
-            }
-            Msg::OpenUrl(url) => {
-                web_sys::console::log_1(&format!("OpenUrl message received for: {url}").into());
-                ctx.link().send_message(Msg::AddDebugMessage(format!(
-                    "Attempting to open URL: {url}"
-                )));
-                let link = ctx.link().clone();
-                spawn_local(async move {
-                    web_sys::console::log_1(
-                        &format!("Starting async open_url call for: {url}").into(),
-                    );
-                    match crate::tauri_api::open_url(url.clone()).await {
-                        Ok(_) => {
-                            web_sys::console::log_1(
-                                &format!("Successfully opened URL: {url}").into(),
-                            );
-                            link.send_message(Msg::AddDebugMessage(format!("✓ Opened URL: {url}")));
-                        }
-                        Err(e) => {
-                            web_sys::console::error_1(
-                                &format!("Failed to open URL {url}: {e}").into(),
-                            );
-                            link.send_message(Msg::SetError(format!("Failed to open URL: {e}")));
-                            link.send_message(Msg::AddDebugMessage(format!(
-                                "✗ Failed to open URL: {url} - Error: {e}"
-                            )));
-                        }
-                    }
-                });
-                false
-            }
-        }
-    }
-
-    fn view(&self, ctx: &Context<Self>) -> Html {
-        let is_dark = ctx.props().is_dark;
-        html! {
-            <div class="w-full max-w-2xl mx-auto">
-                {if self.needs_email_setup && self.is_running && !self.show_tlsforward_form {
-                    html! {
-                        <div class={classes!("mb-6", "p-4", "rounded-lg", "border", if is_dark { "bg-blue-900/20 border-blue-700" } else { "bg-blue-50 border-blue-300" })}>
-                            <h3 class={classes!("text-sm", "font-medium", "mb-2", if is_dark { "text-blue-300" } else { "text-blue-800" })}>
-                                {"Email Required for SSL Certificates"}
-                            </h3>
-                            <p class={classes!("text-xs", "mb-3", if is_dark { "text-blue-200" } else { "text-blue-700" })}>
-                                {"Please provide your email address to enable automatic SSL certificates from Let's Encrypt."}
-                            </p>
-                            <button
-                                onclick={ctx.link().callback(|_| Msg::ShowTlsForwardForm)}
-                                class={classes!("text-sm", "font-medium", "border", "rounded", "px-4", "py-2", "cursor-pointer", "transition-colors", if is_dark { "bg-blue-800 hover:bg-blue-700 border-blue-600 text-white" } else { "bg-blue-600 hover:bg-blue-700 border-blue-700 text-white" })}
-                            >
-                                {"Configure Email"}
-                            </button>
-                        </div>
-                    }
-                } else {
-                    html! {}
-                }}
-
-                <div class="space-y-6">
-                    <div class="space-y-2">
-                        <div class="flex items-center justify-between">
-                            <span class={classes!("text-xs", "uppercase", "tracking-wider", "font-medium", "text-gray-500")}>{"Daemon Status"}</span>
-                            <span class={classes!(
-                                "px-2", "py-1", "rounded", "text-xs", "font-medium", "uppercase", "tracking-wider",
-                                if self.is_running {
-                                    if is_dark { "text-green-400 bg-green-900/50" } else { "text-green-700 bg-green-50" }
-                                } else if is_dark { "text-red-400 bg-red-900/50" } else { "text-red-700 bg-red-50" }
-                            )}>
-                                {if self.is_running {
-                                    "Connected"
-                                } else if self.poll_delay_ms < 500 {
-                                    "Starting..."
-                                } else {
-                                    "Disconnected"
-                                }}
-                            </span>
-                        </div>
-
-                        {if let Some(addr) = &self.listen_address {
-                            html! {
-                                <div class="flex items-center justify-between">
-                                    <span class={classes!("text-xs", "uppercase", "tracking-wider", "font-medium", "text-gray-500")}>{"Listen Address"}</span>
-                                    <span class={classes!("text-sm", "font-mono", if is_dark { "text-gray-200" } else { "text-gray-800" })}>{addr}</span>
-                                </div>
-                            }
-                        } else {
-                            html! {}
-                        }}
-
-                        {if let Some(config) = &self.runtime_config {
-                            html! {
-                                <>
-                                    <div class="flex items-center justify-between">
-                                        <span class={classes!("text-xs", "uppercase", "tracking-wider", "font-medium", "text-gray-500")}>{"Database"}</span>
-                                        <span class={classes!("text-sm", "font-mono", if is_dark { "text-gray-200" } else { "text-gray-800" })}>
-                                            {if config.database_url.contains(":memory:") {
-                                                "In-memory"
-                                            } else if config.database_url.starts_with("sqlite://") {
-                                                "Persistent"
-                                            } else {
-                                                &config.database_url
-                                            }}
-                                        </span>
-                                    </div>
-
-                                    <div class="flex items-center justify-between">
-                                        <span class={classes!("text-xs", "uppercase", "tracking-wider", "font-medium", "text-gray-500")}>{"Providers"}</span>
-                                        <span class={classes!("text-sm", if is_dark { "text-gray-200" } else { "text-gray-800" })}>
-                                            {if config.provider_count > 0 {
-                                                format!("{} configured", config.provider_count)
-                                            } else {
-                                                "None configured".to_string()
-                                            }}
-                                        </span>
-                                    </div>
-
-                                    {if let Some(node_id) = &config.p2p_node_id {
-                                        let short_id = if node_id.len() > 16 {
-                                            format!("{}...{}", &node_id[..8], &node_id[node_id.len()-4..])
-                                        } else {
-                                            node_id.clone()
-                                        };
-                                        html! {
-                                            <div class="flex items-center justify-between">
-                                                <span class={classes!("text-xs", "uppercase", "tracking-wider", "font-medium", "text-gray-500")}>{"P2P Node ID"}</span>
-                                                <span
-                                                    class={classes!("text-xs", "font-mono", "cursor-pointer", if is_dark { "text-gray-200 hover:text-gray-400" } else { "text-gray-800 hover:text-gray-600" })}
-                                                    title={node_id.clone()}
-                                                    onclick={
-                                                        let node_id = node_id.clone();
-                                                        Callback::from(move |_| {
-                                                            if let Some(window) = web_sys::window() {
-                                                                let _ = window.navigator().clipboard().write_text(&node_id);
-                                                            }
-                                                        })
-                                                    }
-                                                >
-                                                    {short_id}
-                                                </span>
-                                            </div>
-                                        }
-                                    } else {
-                                        html! {}
-                                    }}
-
-                                    {if !config.p2p_listen_addresses.is_empty() {
-                                        // Group addresses by type (IPv4 and IPv6)
-                                        let addresses = config.p2p_listen_addresses.join(" ");
-                                        html! {
-                                            <div class="flex items-center justify-between">
-                                                <span class={classes!("text-xs", "uppercase", "tracking-wider", "font-medium", "text-gray-500")}>{"P2P Listen"}</span>
-                                                <span class={classes!("text-xs", "font-mono", "max-w-[200px]", "overflow-hidden", "text-ellipsis", "whitespace-nowrap", "text-right", if is_dark { "text-gray-200" } else { "text-gray-800" })} title={addresses.clone()}>
-                                                    {addresses}
-                                                </span>
-                                            </div>
-                                        }
-                                    } else {
-                                        html! {}
-                                    }}
-
-                                    {if config.tlsforward_enabled || config.tlsforward_state.is_some() {
-                                        html! {
-                                            <div class="flex items-center justify-between">
-                                                <span class={classes!("text-xs", "uppercase", "tracking-wider", "font-medium", "text-gray-500")}>{"TLS Forward"}</span>
-                                                <span class={classes!("text-sm", if is_dark { "text-gray-200" } else { "text-gray-800" })}>
-                                                    {match &config.tlsforward_state {
-                                                        Some(TlsForwardState::Disabled) => "Disabled",
-                                                        Some(TlsForwardState::Disconnected) => "Disconnected",
-                                                        Some(TlsForwardState::Connecting) => "Requesting certificate...",
-                                                        Some(TlsForwardState::Connected { .. }) => "Connected",
-                                                        Some(TlsForwardState::Error(_)) => "Error",
-                                                        None => "Not configured",
-                                                    }}
-                                                </span>
-                                            </div>
-                                        }
-                                    } else if !self.show_tlsforward_form {
-                                        html! {
-                                            <div class="flex items-center justify-between">
-                                                <span class={classes!("text-xs", "uppercase", "tracking-wider", "font-medium", "text-gray-500")}>{"TLS Forward"}</span>
-                                                <button
-                                                    onclick={ctx.link().callback(|_| Msg::ShowTlsForwardForm)}
-                                                    class={classes!("text-xs", "font-medium", "border", "rounded", "px-3", "py-1", "cursor-pointer", "transition-colors", if is_dark { "bg-gray-800 hover:bg-gray-700 border-gray-700 text-gray-300" } else { "bg-white hover:bg-gray-50 border-gray-300 text-gray-700" })}
-                                                >
-                                                    {"Configure"}
-                                                </button>
-                                            </div>
-                                        }
-                                    } else {
-                                        html! {}
-                                    }}
-
-                                    {match &config.tlsforward_state {
-                                        Some(TlsForwardState::Connected { server_address: _, assigned_domain }) => {
-                                            html! {
-                                                <>
-                                                <div class="flex items-center justify-between">
-                                                    <span class={classes!("text-xs", "uppercase", "tracking-wider", "font-medium", "text-gray-500")}>{"TLS Forward Domain"}</span>
-                                                    <div class="flex items-center gap-2">
-                                                        {if let Some(daemon_cfg) = &self.daemon_config {
-                                                            if daemon_cfg.letsencrypt.email.is_some() {
-                                                                // Email configured - show HTTPS URL
-                                                                html! {
-                                                                    <a
-                                                                        href={format!("https://{assigned_domain}")}
-                                                                        class={classes!("text-xs", "font-mono", "font-medium", "underline", if is_dark { "text-green-400 hover:text-green-300" } else { "text-green-600 hover:text-green-700" })}
-                                                                        title="Access your secure AI gateway"
-                                                                        onclick={
-                                                                            let full_url = format!("https://{assigned_domain}");
-                                                                            let link = ctx.link().clone();
-                                                                            Callback::from(move |e: MouseEvent| {
-                                                                                e.prevent_default();
-                                                                                e.stop_propagation();
-                                                                                let url = full_url.clone();
-                                                                                link.send_message(Msg::OpenUrl(url));
-                                                                            })
-                                                                        }
-                                                                    >
-                                                                        {format!("https://{assigned_domain}")}
-                                                                    </a>
-                                                                }
-                                                            } else {
-                                                                // No email - just show domain
-                                                                html! {
-                                                                    <span class={classes!("text-xs", "font-mono", if is_dark { "text-gray-300" } else { "text-gray-700" })}>
-                                                                        {assigned_domain.clone()}
-                                                                    </span>
-                                                                }
-                                                            }
-                                                        } else {
-                                                            html! {
-                                                                <span class={classes!("text-xs", "font-mono", if is_dark { "text-gray-300" } else { "text-gray-700" })}>
-                                                                    {assigned_domain.clone()}
-                                                                </span>
-                                                            }
-                                                        }}
-                                                        <button
-                                                            class={classes!("p-1", if is_dark { "text-gray-400 hover:text-gray-200" } else { "text-gray-400 hover:text-gray-600" })}
-                                                            title="Copy domain to clipboard"
-                                                            onclick={
-                                                                let domain = assigned_domain.clone();
-                                                                Callback::from(move |_| {
-                                                                    if let Some(window) = web_sys::window() {
-                                                                        let _ = window.navigator().clipboard().write_text(&domain);
-                                                                    }
-                                                                })
-                                                            }
-                                                        >
-                                                            <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                                                                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z"></path>
-                                                            </svg>
-                                                        </button>
-                                                    </div>
-                                                </div>
-                                                </>
-                                            }
-                                        }
-                                        Some(TlsForwardState::Error(msg)) => {
-                                            html! {
-                                                <div class="flex items-start justify-between">
-                                                    <span class={classes!("text-xs", "uppercase", "tracking-wider", "font-medium", "text-gray-500")}>{"Status"}</span>
-                                                    <span class={classes!("text-xs", "text-right", "max-w-[200px]", if is_dark { "text-gray-400" } else { "text-gray-500" })}>
-                                                        {msg}
-                                                    </span>
-                                                </div>
-                                            }
-                                        }
-                                        _ => html! {}
-                                    }}
-                                </>
-                            }
-                        } else {
-                            html! {}
-                        }}
-                    </div>
-                </div>
-
-                {if self.show_tlsforward_form && self.is_running {
-                    html! {
-                        <div class="mt-6">
-                            <h4 class={classes!("text-sm", "font-medium", "mb-3", "uppercase", "tracking-wider", if is_dark { "text-gray-400" } else { "text-gray-500" })}>{"Configure TLS Forwarding"}</h4>
-
-                            <p class={classes!("text-sm", "m-0", "mb-4", if is_dark { "text-gray-300" } else { "text-gray-500" })}>
-                                {"TLS forwarding allows you to access your Gate instance via HTTPS with automatic SSL certificates."}
-                            </p>
-
-                            <div class="mb-4">
-                                <label class={classes!("block", "text-sm", "font-medium", "mb-2", if is_dark { "text-gray-200" } else { "text-gray-700" })}>{"Email for Let's Encrypt (required)"}</label>
-                                <input
-                                    type="email"
-                                    value={self.tlsforward_email.clone()}
-                                    oninput={ctx.link().callback(|e: InputEvent| {
-                                        let input = e.target().unwrap().unchecked_into::<web_sys::HtmlInputElement>();
-                                        Msg::UpdateTlsForwardEmail(input.value())
-                                    })}
-                                    placeholder="your@email.com"
-                                    class={classes!("w-full", "py-2", "px-3", "border", "rounded-md", "text-sm", "focus:outline-none", "focus:ring-2", if is_dark { "border-white/20 bg-white/10 text-white placeholder-gray-400 focus:ring-blue-400 focus:border-blue-400 backdrop-blur-sm" } else { "border-gray-300 bg-white text-gray-800 placeholder-gray-400 focus:ring-blue-500 focus:border-blue-500" })}
-                                    disabled={self.tlsforward_loading}
-                                />
-                            </div>
-
-                            <div class="flex gap-2">
-                                <button
-                                    onclick={ctx.link().callback(|_| Msg::ConfigureTlsForward)}
-                                    disabled={self.tlsforward_loading || self.tlsforward_email.is_empty()}
-                                    class={classes!(
-                                        "flex-1", "text-white", "border-none", "rounded-md", "py-2", "px-4", "text-sm", "font-medium",
-                                        if self.tlsforward_loading || self.tlsforward_email.is_empty() {
-                                            if is_dark { "bg-gray-800 border-gray-700 text-gray-600 cursor-not-allowed" } else { "bg-gray-100 border-gray-300 text-gray-400 cursor-not-allowed" }
-                                        } else {
-                                            "bg-green-600 hover:bg-green-700 text-white cursor-pointer"
-                                        }
-                                    )}
-                                >
-                                    {if self.tlsforward_loading { "Configuring..." } else { "Enable TLS Forwarding" }}
-                                </button>
-                                <button
-                                    onclick={ctx.link().callback(|_| Msg::HideTlsForwardForm)}
-                                    disabled={self.tlsforward_loading}
-                                    class={classes!("border", "rounded-md", "py-2", "px-4", "text-sm", "font-medium", "cursor-pointer", "transition-colors", if is_dark { "bg-transparent text-gray-400 border-gray-700 hover:bg-gray-800" } else { "bg-white text-gray-700 border-gray-300 hover:bg-gray-50" })}
-                                >
-                                    {"Cancel"}
-                                </button>
-                            </div>
-                        </div>
-                    }
-                } else {
-                    html! {}
-                }}
-
-                {if !self.is_running {
-                    html! {
-                        <div class="mt-4">
-                            <button
-                                onclick={ctx.link().callback(|_| Msg::StartDaemon)}
-                                class={classes!("w-full", "text-white", "border-none", "rounded", "py-2.5", "px-4", "text-sm", "font-medium", "cursor-pointer", "transition-colors", "duration-200", "bg-green-600", "hover:bg-green-700")}
-                            >
-                                {"Start Daemon"}
-                            </button>
-                        </div>
-                    }
-                } else {
-                    html! {}
-                }}
-
-                {if let Some(error) = &self.error_message {
-                    html! {
-                        <div class={classes!("mt-4", "p-3", "border", "rounded", "text-sm", if is_dark { "bg-red-900/20 border-red-800 text-red-400" } else { "bg-red-50 border-red-200 text-red-700" })}>
-                            <strong>{"Error: "}</strong>{error}
-                        </div>
-                    }
-                } else {
-                    html! {}
-                }}
-                    <div>
-                        <h3 class={classes!("text-sm", "font-medium", "mb-3", "uppercase", "tracking-wider", if is_dark { "text-gray-400" } else { "text-gray-500" })}>{"Connection Status"}</h3>
-                        <button
-                            onclick={ctx.link().callback(|e: MouseEvent| {
-                                web_sys::console::log_1(&"Debug button clicked (from onclick)".into());
-                                e.prevent_default();
-                                e.stop_propagation();
-                                Msg::ToggleDebugLog
-                            })}
-                            class={classes!(
-                                "border", "rounded", "px-3", "py-1", "text-sm", "cursor-pointer", "transition-all",
-                                if self.show_debug_log {
-                                    if is_dark { "bg-gray-700 border-gray-600 text-gray-300 hover:bg-gray-600" } else { "bg-gray-200 border-gray-300 text-gray-700 hover:bg-gray-300" }
-                                } else if is_dark { "bg-gray-800 border-gray-700 text-gray-400 hover:bg-gray-700" } else { "bg-white border-gray-300 text-gray-600 hover:bg-gray-100" }
-                            )}
-                            title={if self.show_debug_log { "Hide debug log" } else { "Show debug log" }}
-                        >
-                            {if self.show_debug_log { "🐛 ON" } else { "🐛" }}
-                        </button>
-                    </div>
-
-                {if self.show_debug_log && !self.debug_messages.is_empty() {
-                    html! {
-                        <div class={classes!("mt-4", "p-3", "border", "rounded", "text-xs", "font-mono", if is_dark { "bg-gray-800 border-gray-700 text-gray-400" } else { "bg-gray-50 border-gray-300 text-gray-700" })}>
-                            <div class="font-semibold mb-2">{"Debug Log:"}</div>
-                            {for self.debug_messages.iter().map(|msg| {
-                                html! { <div>{msg}</div> }
-                            })}
-                        </div>
-                    }
-                } else {
-                    html! {}
-                }}
-            </div>
-        }
-    }
-}
diff --git a/crates/frontend-tauri/src/components/mod.rs b/crates/frontend-tauri/src/components/mod.rs
deleted file mode 100644
index bc0c2f39..00000000
--- a/crates/frontend-tauri/src/components/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-pub mod daemon_status;
-
-pub use daemon_status::DaemonStatusComponent;
diff --git a/crates/frontend-tauri/src/lib.rs b/crates/frontend-tauri/src/lib.rs
deleted file mode 100644
index b10579e9..00000000
--- a/crates/frontend-tauri/src/lib.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-pub mod app;
-pub mod components;
-pub mod tauri_api;
-
-pub use app::TauriApp;
diff --git a/crates/frontend-tauri/src/main.rs b/crates/frontend-tauri/src/main.rs
deleted file mode 100644
index 26d81c33..00000000
--- a/crates/frontend-tauri/src/main.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-mod app;
-mod components;
-mod tauri_api;
-
-use app::TauriApp;
-
-fn main() {
-    wasm_logger::init(wasm_logger::Config::default());
-    let document = web_sys::window().unwrap().document().unwrap();
-    let element = document
-        .get_element_by_id("app")
-        .expect("Failed to find app element");
-    yew::Renderer::<TauriApp>::with_root(element).render();
-}
diff --git a/crates/frontend-tauri/src/tauri_api.rs b/crates/frontend-tauri/src/tauri_api.rs
deleted file mode 100644
index 5f64d460..00000000
--- a/crates/frontend-tauri/src/tauri_api.rs
+++ /dev/null
@@ -1,235 +0,0 @@
-#![allow(dead_code)]
-
-use serde::{Deserialize, Serialize};
-use wasm_bindgen::prelude::*;
-
-// Tauri v2 API
-#[wasm_bindgen(inline_js = "
-export function invoke_tauri_command(cmd, args) {
-    if (window.__TAURI__?.core?.invoke) {
-        return window.__TAURI__.core.invoke(cmd, args);
-    }
-    console.error('Tauri API not found. Ensure withGlobalTauri is set to true in tauri.conf.json');
-    return Promise.reject('Tauri API not available');
-}
-
-export function check_tauri_available() {
-    return !!(window.__TAURI__?.core?.invoke);
-}
-")]
-extern "C" {
-    #[wasm_bindgen(js_name = invoke_tauri_command)]
-    async fn tauri_invoke(cmd: &str, args: JsValue) -> JsValue;
-
-    #[wasm_bindgen(js_name = check_tauri_available)]
-    fn check_tauri() -> bool;
-}
-
-// Helper to log invoke calls
-async fn invoke(cmd: &str, args: JsValue) -> Result<JsValue, String> {
-    web_sys::console::log_1(&format!("Invoking Tauri command: {cmd}").into());
-
-    // Check if Tauri is available
-    if !check_tauri() {
-        web_sys::console::error_1(&"Tauri API not available!".into());
-        return Err("Tauri API not available".to_string());
-    }
-
-    let result = tauri_invoke(cmd, args).await;
-    web_sys::console::log_1(&format!("Tauri command {cmd} completed").into());
-    Ok(result)
-}
-
-// Minimal Settings struct that matches backend
-#[derive(Clone, Serialize, Deserialize, PartialEq)]
-pub struct Settings {
-    pub server: ServerConfig,
-    pub letsencrypt: LetsEncryptConfig,
-    pub tlsforward: TlsForwardConfig,
-}
-
-#[derive(Clone, Serialize, Deserialize, PartialEq)]
-pub struct ServerConfig {
-    pub host: String,
-    pub port: u16,
-}
-
-#[derive(Clone, Serialize, Deserialize, PartialEq)]
-pub struct LetsEncryptConfig {
-    pub enabled: bool,
-    pub email: Option<String>,
-}
-
-#[derive(Clone, Serialize, Deserialize, PartialEq)]
-pub struct TlsForwardConfig {
-    pub enabled: bool,
-}
-
-#[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
-pub struct DaemonRuntimeStatus {
-    pub running: bool,
-    pub listen_address: Option<String>,
-    pub has_providers: bool,
-}
-
-#[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
-pub enum TlsForwardState {
-    Disabled,
-    Disconnected,
-    Connecting,
-    Connected {
-        server_address: String,
-        assigned_domain: String,
-    },
-    Error(String),
-}
-
-#[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
-pub struct DaemonRuntimeConfig {
-    pub listen_address: String,
-    pub database_url: String,
-    pub provider_count: usize,
-    pub auth_enabled: bool,
-    pub webauthn_enabled: bool,
-    pub p2p_node_id: Option<String>,
-    pub p2p_listen_addresses: Vec<String>,
-    pub tlsforward_enabled: bool,
-    pub tlsforward_state: Option<TlsForwardState>,
-    pub needs_bootstrap: bool,
-}
-
-/// Start the daemon
-pub async fn start_daemon() -> Result<String, String> {
-    let result = invoke("start_daemon", JsValue::UNDEFINED).await?;
-    serde_wasm_bindgen::from_value::<String>(result).map_err(|e| e.to_string())
-}
-
-/// Stop the daemon
-pub async fn stop_daemon() -> Result<String, String> {
-    let result = invoke("stop_daemon", JsValue::UNDEFINED).await?;
-    serde_wasm_bindgen::from_value::<String>(result).map_err(|e| e.to_string())
-}
-
-/// Check if daemon is running
-pub async fn daemon_status() -> Result<bool, String> {
-    let result = invoke("daemon_status", JsValue::UNDEFINED).await?;
-    serde_wasm_bindgen::from_value::<bool>(result).map_err(|e| e.to_string())
-}
-
-/// Get daemon configuration
-pub async fn get_daemon_config() -> Result<Settings, String> {
-    let result = invoke("get_daemon_config", JsValue::UNDEFINED).await?;
-    serde_wasm_bindgen::from_value::<Settings>(result).map_err(|e| e.to_string())
-}
-
-/// Get daemon runtime status
-pub async fn get_daemon_status() -> Result<DaemonRuntimeStatus, String> {
-    web_sys::console::log_1(&"Getting daemon status...".into());
-    let result = invoke("get_daemon_status", JsValue::UNDEFINED).await?;
-    serde_wasm_bindgen::from_value::<DaemonRuntimeStatus>(result).map_err(|e| {
-        web_sys::console::error_1(&format!("Failed to deserialize status: {e}").into());
-        e.to_string()
-    })
-}
-
-/// Get daemon runtime configuration
-pub async fn get_daemon_runtime_config() -> Result<DaemonRuntimeConfig, String> {
-    let result = invoke("get_daemon_runtime_config", JsValue::UNDEFINED).await?;
-    serde_wasm_bindgen::from_value::<DaemonRuntimeConfig>(result).map_err(|e| e.to_string())
-}
-
-/// Restart daemon
-pub async fn restart_daemon() -> Result<String, String> {
-    let result = invoke("restart_daemon", JsValue::UNDEFINED).await?;
-
-    serde_wasm_bindgen::from_value::<String>(result).map_err(|e| e.to_string())
-}
-
-/// Get TLS forward status
-pub async fn get_tlsforward_status() -> Result<Option<TlsForwardState>, String> {
-    let result = invoke("get_tlsforward_status", JsValue::UNDEFINED).await?;
-
-    serde_wasm_bindgen::from_value::<Option<TlsForwardState>>(result).map_err(|e| e.to_string())
-}
-
-/// Configure TLS forward with email
-pub async fn configure_tlsforward(email: String) -> Result<String, String> {
-    let args = serde_wasm_bindgen::to_value(&serde_json::json!({ "email": email }))
-        .map_err(|e| e.to_string())?;
-
-    let result = invoke("configure_tlsforward", args).await?;
-
-    serde_wasm_bindgen::from_value::<String>(result).map_err(|e| e.to_string())
-}
-
-/// Enable TLS forward
-pub async fn enable_tlsforward() -> Result<String, String> {
-    let result = invoke("enable_tlsforward", JsValue::UNDEFINED).await?;
-
-    serde_wasm_bindgen::from_value::<String>(result).map_err(|e| e.to_string())
-}
-
-/// Disable TLS forward
-pub async fn disable_tlsforward() -> Result<String, String> {
-    let result = invoke("disable_tlsforward", JsValue::UNDEFINED).await?;
-
-    serde_wasm_bindgen::from_value::<String>(result).map_err(|e| e.to_string())
-}
-
-/// Open URL in default browser using Tauri opener plugin
-pub async fn open_url(url: String) -> Result<(), String> {
-    web_sys::console::log_1(&format!("Attempting to open URL: {url}").into());
-
-    // Validate URL to restrict to Hellas private URLs only
-    if !is_allowed_url(&url) {
-        web_sys::console::error_1(&format!("URL not allowed: {url}").into());
-        return Err(format!("URL not allowed: {url}"));
-    }
-
-    // Use the opener plugin through Tauri's invoke system
-    let args = serde_wasm_bindgen::to_value(&serde_json::json!({ "url": url }))
-        .map_err(|e| e.to_string())?;
-
-    match invoke("plugin:opener|open_url", args).await {
-        Ok(_) => {
-            web_sys::console::log_1(&format!("Successfully opened URL: {url}").into());
-            Ok(())
-        }
-        Err(e) => {
-            web_sys::console::error_1(&format!("Failed to open URL: {e}").into());
-            Err(format!("Failed to open URL: {e}"))
-        }
-    }
-}
-
-/// Get bootstrap token for initial admin setup
-pub async fn get_bootstrap_token() -> Result<Option<String>, String> {
-    let result = invoke("get_bootstrap_token", JsValue::UNDEFINED).await?;
-    serde_wasm_bindgen::from_value::<Option<String>>(result).map_err(|e| e.to_string())
-}
-
-/// Check if a URL is allowed to be opened
-fn is_allowed_url(url: &str) -> bool {
-    // Allow localhost URLs for development
-    if url.starts_with("http://localhost") || url.starts_with("https://localhost") {
-        return true;
-    }
-
-    // Allow Hellas AI domains
-    if url.starts_with("https://hellas.ai") || url.starts_with("https://*.hellas.ai") {
-        return true;
-    }
-
-    // Allow Hellas private/internal URLs
-    if url.contains(".hellas.") || url.contains("hellas-") {
-        return true;
-    }
-
-    // Allow Gate-specific domains
-    if url.contains("gate.") || url.contains("-gate.") {
-        return true;
-    }
-
-    // Deny everything else
-    false
-}
diff --git a/crates/frontend-tauri/style.css b/crates/frontend-tauri/style.css
deleted file mode 100644
index 141b37b5..00000000
--- a/crates/frontend-tauri/style.css
+++ /dev/null
@@ -1,52 +0,0 @@
-@import "tailwindcss";
-@config "./tailwind.config.js";
-@source "index.html";
-@source "src/**/*.rs";
-@source "../frontend-common/src/**/*.rs";
-@source "../chat-ui/src/**/*.rs";
-
-@theme {
-  --color-gray-50: #f9fafb;
-  --color-gray-100: #f3f4f6;
-  --color-gray-200: #e5e7eb;
-  --color-gray-300: #d1d5db;
-  --color-gray-400: #9ca3af;
-  --color-gray-500: #6b7280;
-  --color-gray-600: #4b5563;
-  --color-gray-700: #374151;
-  --color-gray-800: #1f2937;
-  --color-gray-900: #111827;
-  --color-blue-50: #eff6ff;
-  --color-blue-100: #dbeafe;
-  --color-blue-200: #bfdbfe;
-  --color-blue-300: #93c5fd;
-  --color-blue-400: #60a5fa;
-  --color-blue-500: #3b82f6;
-  --color-blue-600: #2563eb;
-  --color-blue-700: #1d4ed8;
-  --color-blue-800: #1e40af;
-  --color-blue-900: #1e3a8a;
-  --color-purple-500: #8b5cf6;
-  --color-purple-600: #7c3aed;
-  --color-purple-900: #581c87;
-  --color-green-400: #4ade80;
-  --color-green-600: #16a34a;
-  --color-green-700: #15803d;
-  --color-red-400: #f87171;
-  --color-red-500: #ef4444;
-  --color-red-600: #dc2626;
-  --color-red-700: #b91c1c;
-  --color-white: #ffffff;
-}
-
-/* Clean, minimal styling */
-body {
-  margin: 0;
-  padding: 0;
-  overflow: hidden;
-}
-
-#app {
-  height: 100vh;
-  width: 100vw;
-}
diff --git a/crates/frontend-tauri/tailwind.config.js b/crates/frontend-tauri/tailwind.config.js
deleted file mode 100644
index b3200035..00000000
--- a/crates/frontend-tauri/tailwind.config.js
+++ /dev/null
@@ -1,30 +0,0 @@
-module.exports = {
-  darkMode: 'class',
-  content: [
-    "./index.html",
-    "./src/**/*.{rs,html}",
-    "../frontend-common/src/**/*.rs",
-    "../chat-ui/src/**/*.rs",
-  ],
-  theme: {
-    extend: {
-      animation: {
-        'spin': 'spin 1s linear infinite',
-        'pulse-dot': 'pulse-dot 1.4s ease-in-out infinite',
-      },
-      keyframes: {
-        'pulse-dot': {
-          '0%, 80%, 100%': {
-            opacity: '0.3',
-            transform: 'scale(0.8)',
-          },
-          '40%': {
-            opacity: '1',
-            transform: 'scale(1)',
-          },
-        },
-      },
-    },
-  },
-  plugins: [],
-}
\ No newline at end of file
diff --git a/crates/gui/Cargo.toml b/crates/gui/Cargo.toml
deleted file mode 100644
index 933e4120..00000000
--- a/crates/gui/Cargo.toml
+++ /dev/null
@@ -1,29 +0,0 @@
-[package]
-name = "gate-gui"
-version.workspace = true
-edition.workspace = true
-authors.workspace = true
-license.workspace = true
-
-[dependencies]
-tauri = { version = "2", features = ["tray-icon", "rustls-tls"] }
-tauri-plugin-opener = "2"
-tokio = { workspace = true, features = ["macros", "rt-multi-thread", "time", "sync"] }
-gate-daemon = { path = "../daemon" }
-gate-core = { workspace = true }
-gate-http = { workspace = true }
-gate-sqlx = { workspace = true }
-gate-p2p = { path = "../p2p" }
-gate-tlsforward = { path = "../tlsforward" }
-axum = { workspace = true }
-anyhow = { workspace = true }
-tracing = { workspace = true }
-tracing-subscriber = { workspace = true }
-serde = { workspace = true, features = ["derive"] }
-serde_json = { workspace = true }
-hex = "0.4"
-rand = { workspace = true }
-rustls = { version = "0.23", default-features = false, features = ["ring"] }
-
-[build-dependencies]
-tauri-build = { version = "2", features = [] }
diff --git a/crates/gui/README.md b/crates/gui/README.md
deleted file mode 100644
index d20acdcb..00000000
--- a/crates/gui/README.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# Gate GUI with Embedded Daemon
-
-This is the Tauri desktop application for Gate that includes an embedded daemon server.
-
-## Architecture
-
-The GUI app runs the Gate daemon as an embedded library within the same process, rather than spawning it as a separate binary.
-
-The GUI frontend (frontend-tauri) itself is a minimal widget that shows essential info (e.g boostrap token) and directs user to the localhost server (frontend-daemon).
-
-## Development
-
-To run the GUI app in development mode:
-
-```bash
-make gui-build-dev
-./target/debug/gate_gui
-```
-
-To build for production:
-
-```bash
-make gui-build
-./target/release/gate_gui
-```
diff --git a/crates/gui/build.rs b/crates/gui/build.rs
deleted file mode 100644
index 90a6a0d6..00000000
--- a/crates/gui/build.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-use std::fs;
-use std::path::Path;
-
-fn main() {
-    // Copy frontend-daemon dist files to resources directory
-    let frontend_daemon_dist = Path::new("../frontend-daemon/dist");
-    let resources_dir = Path::new("resources/frontend-daemon");
-
-    // Remove old resources directory if it exists
-    if resources_dir.exists() {
-        fs::remove_dir_all(resources_dir).expect("Failed to remove old resources");
-    }
-
-    // Always create resources directory, even if empty
-    fs::create_dir_all(resources_dir).expect("Failed to create resources directory");
-
-    // Only copy if frontend-daemon dist exists
-    if frontend_daemon_dist.exists() {
-        println!("cargo:rerun-if-changed=../frontend-daemon/dist");
-
-        // Copy all files from frontend-daemon/dist to resources/frontend-daemon
-        copy_dir_all(frontend_daemon_dist, resources_dir)
-            .expect("Failed to copy frontend-daemon files");
-
-        println!("cargo:warning=Copied frontend-daemon files to resources directory");
-    } else {
-        println!("cargo:warning=frontend-daemon dist directory not found, skipping resource copy");
-    }
-
-    tauri_build::build()
-}
-
-fn copy_dir_all(src: &Path, dst: &Path) -> std::io::Result<()> {
-    fs::create_dir_all(dst)?;
-
-    for entry in fs::read_dir(src)? {
-        let entry = entry?;
-        let path = entry.path();
-        let file_name = entry.file_name();
-        let dst_path = dst.join(&file_name);
-
-        if path.is_dir() {
-            copy_dir_all(&path, &dst_path)?;
-        } else {
-            fs::copy(&path, &dst_path)?;
-        }
-    }
-
-    Ok(())
-}
diff --git a/crates/gui/capabilities/default.json b/crates/gui/capabilities/default.json
deleted file mode 100644
index 33c315f9..00000000
--- a/crates/gui/capabilities/default.json
+++ /dev/null
@@ -1,24 +0,0 @@
-{
-  "$schema": "../gen/schemas/desktop-schema.json",
-  "identifier": "default",
-  "description": "Default permissions",
-  "windows": [
-    "main"
-  ],
-  "permissions": [
-    "core:default",
-    "opener:default",
-    {
-      "identifier": "opener:allow-open-url",
-      "allow": [
-        {
-          "url": "https://*.private.hellas.ai"
-        },
-        {
-          "url": "https://*.private.hellas.ai/*"
-        }
-      ]
-    },
-    "opener:allow-open-path"
-  ]
-}
\ No newline at end of file
diff --git a/crates/gui/entitlements.plist b/crates/gui/entitlements.plist
deleted file mode 100644
index cb210fe7..00000000
--- a/crates/gui/entitlements.plist
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <!-- Allow app to run without being sandboxed -->
-    <key>com.apple.security.app-sandbox</key>
-    <false/>
-    
-    <!-- Allow network connections -->
-    <key>com.apple.security.network.client</key>
-    <true/>
-    <key>com.apple.security.network.server</key>
-    <true/>
-    
-    <!-- Allow file access -->
-    <key>com.apple.security.files.user-selected.read-write</key>
-    <true/>
-    
-    <!-- Hardened runtime -->
-    <key>com.apple.security.cs.allow-jit</key>
-    <true/>
-    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
-    <true/>
-    <key>com.apple.security.cs.disable-library-validation</key>
-    <true/>
-</dict>
-</plist>
\ No newline at end of file
diff --git a/crates/gui/icons/Hellas_Token_Black_Solid.svg b/crates/gui/icons/Hellas_Token_Black_Solid.svg
deleted file mode 100644
index 6eeb983a..00000000
--- a/crates/gui/icons/Hellas_Token_Black_Solid.svg
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 27.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 315 315" style="enable-background:new 0 0 315 315;" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#1C1C1C;}
-</style>
-<path class="st0" d="M259.52,106.71l-51.24-51.24c-3.89-3.89-9.06-6.03-14.56-6.03h-72.46c-5.5,0-10.67,2.14-14.55,6.03
-	l-51.24,51.24c-3.89,3.89-6.03,9.06-6.03,14.55v72.46c0,5.5,2.14,10.67,6.03,14.56l51.24,51.24c3.89,3.89,9.06,6.03,14.56,6.03
-	h72.46c5.5,0,10.67-2.14,14.56-6.03l51.24-51.24c3.89-3.89,6.03-9.06,6.03-14.56v-72.46C265.55,115.77,263.41,110.6,259.52,106.71z
-	 M214,110.88c0,1.2-0.98,2.18-2.18,2.18h-16.55c-1.2,0-2.18,0.98-2.18,2.18v35.5h11.51c1.2,0,2.18,0.98,2.18,2.18v9.15
-	c0,1.2-0.98,2.18-2.18,2.18H193.1v35.5c0,1.2,0.98,2.18,2.18,2.18h16.55c1.2,0,2.18,0.98,2.18,2.18v12.53c0,1.2-0.98,2.18-2.18,2.18
-	h-8.15c-1.93,0-3.78-0.77-5.15-2.13l-19-21.25c-2.36-2.36-3.69-5.57-3.69-8.91v-22.29h-36.68v22.29c0,3.34-1.33,6.54-3.69,8.91
-	l-19,21.25c-1.37,1.37-3.22,2.13-5.15,2.13h-8.15c-1.2,0-2.18-0.98-2.18-2.18v-12.53c0-1.2,0.98-2.18,2.18-2.18h16.55
-	c1.2,0,2.18-0.98,2.18-2.18v-35.5h-11.51c-1.2,0-2.18-0.98-2.18-2.18v-9.15c0-1.2,0.98-2.18,2.18-2.18h11.51v-35.5
-	c0-1.2-0.98-2.18-2.18-2.18h-16.55c-1.2,0-2.18-0.98-2.18-2.18V98.35c0-1.2,0.98-2.18,2.18-2.18h8.15c1.93,0,3.78,0.77,5.15,2.13
-	l19,21.25c2.36,2.36,3.69,5.57,3.69,8.91v22.28h36.68v-22.28c0-3.34,1.33-6.54,3.69-8.91l19-21.25c1.37-1.37,3.22-2.13,5.15-2.13
-	h8.15c1.2,0,2.18,0.98,2.18,2.18V110.88z"/>
-</svg>
diff --git a/crates/gui/icons/Hellas_Token_White_Solid.svg b/crates/gui/icons/Hellas_Token_White_Solid.svg
deleted file mode 100644
index 4e2df956..00000000
--- a/crates/gui/icons/Hellas_Token_White_Solid.svg
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 27.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 315 315" style="enable-background:new 0 0 315 315;" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#EAEEF4;}
-</style>
-<path class="st0" d="M259.52,106.71l-51.24-51.24c-3.89-3.89-9.06-6.03-14.56-6.03h-72.46c-5.5,0-10.67,2.14-14.55,6.03
-	l-51.24,51.24c-3.89,3.89-6.03,9.06-6.03,14.55v72.46c0,5.5,2.14,10.67,6.03,14.56l51.24,51.24c3.89,3.89,9.06,6.03,14.56,6.03
-	h72.46c5.5,0,10.67-2.14,14.56-6.03l51.24-51.24c3.89-3.89,6.03-9.06,6.03-14.56v-72.46C265.55,115.77,263.41,110.6,259.52,106.71z
-	 M214,110.88c0,1.2-0.98,2.18-2.18,2.18h-16.55c-1.2,0-2.18,0.98-2.18,2.18v35.5h11.51c1.2,0,2.18,0.98,2.18,2.18v9.15
-	c0,1.2-0.98,2.18-2.18,2.18H193.1v35.5c0,1.2,0.98,2.18,2.18,2.18h16.55c1.2,0,2.18,0.98,2.18,2.18v12.53c0,1.2-0.98,2.18-2.18,2.18
-	h-8.15c-1.93,0-3.78-0.77-5.15-2.13l-19-21.25c-2.36-2.36-3.69-5.57-3.69-8.91v-22.29h-36.68v22.29c0,3.34-1.33,6.54-3.69,8.91
-	l-19,21.25c-1.37,1.37-3.22,2.13-5.15,2.13h-8.15c-1.2,0-2.18-0.98-2.18-2.18v-12.53c0-1.2,0.98-2.18,2.18-2.18h16.55
-	c1.2,0,2.18-0.98,2.18-2.18v-35.5h-11.51c-1.2,0-2.18-0.98-2.18-2.18v-9.15c0-1.2,0.98-2.18,2.18-2.18h11.51v-35.5
-	c0-1.2-0.98-2.18-2.18-2.18h-16.55c-1.2,0-2.18-0.98-2.18-2.18V98.35c0-1.2,0.98-2.18,2.18-2.18h8.15c1.93,0,3.78,0.77,5.15,2.13
-	l19,21.25c2.36,2.36,3.69,5.57,3.69,8.91v22.28h36.68v-22.28c0-3.34,1.33-6.54,3.69-8.91l19-21.25c1.37-1.37,3.22-2.13,5.15-2.13
-	h8.15c1.2,0,2.18,0.98,2.18,2.18V110.88z"/>
-</svg>
diff --git a/crates/gui/icons/convert_icon.py b/crates/gui/icons/convert_icon.py
deleted file mode 100644
index 8f4b0fce..00000000
--- a/crates/gui/icons/convert_icon.py
+++ /dev/null
@@ -1,107 +0,0 @@
-#!/usr/bin/env python3
-import subprocess
-import sys
-import os
-import argparse
-from PIL import Image
-import cairosvg
-
-def convert_svg_to_png(svg_path, png_path, width, height):
-    """Convert SVG to PNG using cairosvg"""
-    cairosvg.svg2png(url=svg_path, write_to=png_path, 
-                     output_width=width, output_height=height)
-    print(f"Created {png_path} ({width}x{height})")
-    return True
-
-def create_ico_file(png_sizes, ico_path):
-    """Create Windows .ico file from multiple PNG sizes"""
-    # Load all PNG images
-    images = []
-    for size, path in png_sizes:
-        if os.path.exists(path):
-            img = Image.open(path)
-            images.append(img)
-    
-    if images:
-        # Save as ICO with multiple sizes
-        images[0].save(ico_path, format='ICO', sizes=[(img.width, img.height) for img in images])
-        print(f"Created {ico_path} with {len(images)} sizes")
-        return True
-    return False
-
-def create_icns_file(svg_file, icns_path):
-    """Create macOS .icns file"""
-    # Create iconset directory structure
-    iconset_path = icns_path.replace('.icns', '.iconset')
-    os.makedirs(iconset_path, exist_ok=True)
-    
-    # Define required sizes for icns
-    sizes = [
-        (16, 'icon_16x16.png'),
-        (32, 'icon_16x16@2x.png'),
-        (32, 'icon_32x32.png'),
-        (64, 'icon_32x32@2x.png'),
-        (128, 'icon_128x128.png'),
-        (256, 'icon_128x128@2x.png'),
-        (256, 'icon_256x256.png'),
-        (512, 'icon_256x256@2x.png'),
-        (512, 'icon_512x512.png'),
-        (1024, 'icon_512x512@2x.png'),
-    ]
-    
-    # Convert to required sizes
-    for size, filename in sizes:
-        output_path = os.path.join(iconset_path, filename)
-        convert_svg_to_png(svg_file, output_path, size, size)
-    
-    # Convert iconset to icns using iconutil
-    subprocess.run(['iconutil', '-c', 'icns', iconset_path, '-o', icns_path])
-    
-    # Clean up iconset
-    subprocess.run(['rm', '-rf', iconset_path])
-    print(f"Created {icns_path}")
-    return True
-
-# Main conversion
-if __name__ == "__main__":
-    # Parse command line arguments
-    parser = argparse.ArgumentParser(description='Convert SVG icon to various formats')
-    parser.add_argument('svg_path', nargs='?', default='gate-icon.svg',
-                        help='Path to the SVG file to convert (default: gate-icon.svg)')
-    args = parser.parse_args()
-    
-    # Change to icons directory
-    os.chdir(os.path.dirname(os.path.abspath(__file__)))
-    
-    svg_file = args.svg_path
-    
-    # Convert to required PNG sizes
-    sizes = [
-        (32, '32x32.png'),
-        (128, '128x128.png'),
-        (256, '128x128@2x.png'),
-    ]
-    
-    png_files = []
-    for size, filename in sizes:
-        if convert_svg_to_png(svg_file, filename, size, size):
-            png_files.append((size, filename))
-    
-    # Create .ico file for Windows
-    if png_files:
-        # Add more sizes for better .ico
-        extra_sizes = [(16, '16x16.png'), (48, '48x48.png'), (256, '256x256.png')]
-        for size, filename in extra_sizes:
-            if not os.path.exists(filename):
-                convert_svg_to_png(svg_file, filename, size, size)
-                png_files.append((size, filename))
-        
-        create_ico_file(png_files, 'icon.ico')
-        
-        # Clean up extra files
-        for _, filename in extra_sizes:
-            if os.path.exists(filename):
-                os.remove(filename)
-    
-    # Create .icns file for macOS
-    create_icns_file(svg_file, 'icon.icns')
\ No newline at end of file
diff --git a/crates/gui/icons/gate-icon.svg b/crates/gui/icons/gate-icon.svg
deleted file mode 100644
index 6eeb983a..00000000
--- a/crates/gui/icons/gate-icon.svg
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 27.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 315 315" style="enable-background:new 0 0 315 315;" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#1C1C1C;}
-</style>
-<path class="st0" d="M259.52,106.71l-51.24-51.24c-3.89-3.89-9.06-6.03-14.56-6.03h-72.46c-5.5,0-10.67,2.14-14.55,6.03
-	l-51.24,51.24c-3.89,3.89-6.03,9.06-6.03,14.55v72.46c0,5.5,2.14,10.67,6.03,14.56l51.24,51.24c3.89,3.89,9.06,6.03,14.56,6.03
-	h72.46c5.5,0,10.67-2.14,14.56-6.03l51.24-51.24c3.89-3.89,6.03-9.06,6.03-14.56v-72.46C265.55,115.77,263.41,110.6,259.52,106.71z
-	 M214,110.88c0,1.2-0.98,2.18-2.18,2.18h-16.55c-1.2,0-2.18,0.98-2.18,2.18v35.5h11.51c1.2,0,2.18,0.98,2.18,2.18v9.15
-	c0,1.2-0.98,2.18-2.18,2.18H193.1v35.5c0,1.2,0.98,2.18,2.18,2.18h16.55c1.2,0,2.18,0.98,2.18,2.18v12.53c0,1.2-0.98,2.18-2.18,2.18
-	h-8.15c-1.93,0-3.78-0.77-5.15-2.13l-19-21.25c-2.36-2.36-3.69-5.57-3.69-8.91v-22.29h-36.68v22.29c0,3.34-1.33,6.54-3.69,8.91
-	l-19,21.25c-1.37,1.37-3.22,2.13-5.15,2.13h-8.15c-1.2,0-2.18-0.98-2.18-2.18v-12.53c0-1.2,0.98-2.18,2.18-2.18h16.55
-	c1.2,0,2.18-0.98,2.18-2.18v-35.5h-11.51c-1.2,0-2.18-0.98-2.18-2.18v-9.15c0-1.2,0.98-2.18,2.18-2.18h11.51v-35.5
-	c0-1.2-0.98-2.18-2.18-2.18h-16.55c-1.2,0-2.18-0.98-2.18-2.18V98.35c0-1.2,0.98-2.18,2.18-2.18h8.15c1.93,0,3.78,0.77,5.15,2.13
-	l19,21.25c2.36,2.36,3.69,5.57,3.69,8.91v22.28h36.68v-22.28c0-3.34,1.33-6.54,3.69-8.91l19-21.25c1.37-1.37,3.22-2.13,5.15-2.13
-	h8.15c1.2,0,2.18,0.98,2.18,2.18V110.88z"/>
-</svg>
diff --git a/crates/gui/src/commands.rs b/crates/gui/src/commands.rs
deleted file mode 100644
index 118d5440..00000000
--- a/crates/gui/src/commands.rs
+++ /dev/null
@@ -1,209 +0,0 @@
-use gate_daemon::types::DaemonRuntimeConfigResponse;
-use gate_daemon::{Daemon, DaemonStatus, Settings, StateDir};
-use tauri::path::BaseDirectory;
-use tauri::{AppHandle, Manager, State};
-
-#[tauri::command]
-pub async fn start_daemon(app: AppHandle) -> Result<String, String> {
-    // Build daemon
-    let state_dir = StateDir::new()
-        .await
-        .map_err(|e| format!("Failed to create state directory: {e}"))?;
-    let default_config_path = state_dir.config_path();
-    let mut builder = Daemon::builder().with_state_dir(state_dir);
-
-    // Load configuration if specified
-    if default_config_path.exists() {
-        info!(
-            "Loading configuration from default path: {}",
-            default_config_path.display()
-        );
-        builder = builder.with_settings(
-            Settings::load_from_file(&default_config_path)
-                .map_err(|e| format!("Failed to load settings: {e}"))?,
-        );
-    } else {
-        info!("No configuration found, creating one using default settings");
-        let settings = Settings::default();
-        settings
-            .save_to_file(&default_config_path)
-            .await
-            .map_err(|e| {
-                format!(
-                    "Failed to save default settings to {}: {e}",
-                    default_config_path.display()
-                )
-            })?;
-        builder = builder.with_settings(settings);
-    }
-
-    // Resolve static directory path for frontend files
-    let static_dir = if tauri::is_dev() {
-        // Development mode - use source directory
-        let dir = "crates/frontend-daemon/dist".to_string();
-        info!("Running in Tauri dev mode, using static directory: {}", dir);
-        dir
-    } else {
-        // Production mode - resolve Tauri resources
-        let path = app
-            .path()
-            .resolve("frontend-daemon", BaseDirectory::Resource)
-            .map_err(|e| format!("Failed to resolve frontend resources: {e}"))?;
-        let dir = path.to_string_lossy().to_string();
-        info!("Running in Tauri production mode, resolved static directory: {dir}");
-        dir
-    };
-    builder = builder.with_static_dir(static_dir);
-
-    let daemon = builder
-        .build()
-        .await
-        .map_err(|e| format!("Failed to build daemon: {e}"))?;
-
-    let address = daemon
-        .server_address()
-        .await
-        .map_err(|e| format!("Failed to get server address: {e}"))?;
-
-    // Spawn server task
-    let daemon_clone = daemon.clone();
-    tokio::spawn(async move {
-        if let Err(e) = daemon_clone.serve().await {
-            error!("Server error: {}", e);
-        }
-    });
-
-    // Update the managed state with the new daemon
-    app.manage(daemon);
-
-    Ok(format!("Daemon started at http://{address}"))
-}
-
-#[tauri::command]
-pub async fn stop_daemon(daemon: State<'_, Option<Daemon>>) -> Result<String, String> {
-    let daemon = daemon.as_ref().ok_or("Daemon not running")?;
-    daemon
-        .system_identity()
-        .shutdown()
-        .await
-        .map_err(|e| format!("Failed to shutdown daemon: {e}"))?;
-
-    Ok("Daemon stopped successfully".to_string())
-}
-
-#[tauri::command]
-pub async fn daemon_status(daemon: State<'_, Option<Daemon>>) -> Result<bool, String> {
-    let daemon = daemon.as_ref().ok_or("Daemon not running")?;
-    Ok(daemon.status().await.map(|s| s.running).unwrap_or(false))
-}
-
-#[tauri::command]
-pub async fn get_daemon_config(daemon: State<'_, Daemon>) -> Result<Settings, String> {
-    daemon
-        .get_settings()
-        .await
-        .map_err(|e| format!("Failed to get config: {e}"))
-}
-
-#[tauri::command]
-pub async fn restart_daemon(
-    daemon: State<'_, Option<Daemon>>,
-    app: AppHandle,
-) -> Result<String, String> {
-    // Stop if running
-    let _ = stop_daemon(daemon).await;
-    app.manage(None::<Daemon>);
-
-    // Start with new config
-    start_daemon(app).await
-}
-
-#[tauri::command]
-pub async fn get_daemon_status(daemon: State<'_, Daemon>) -> Result<DaemonStatus, String> {
-    daemon
-        .status()
-        .await
-        .map_err(|e| format!("Failed to get status: {e}"))
-}
-
-#[tauri::command]
-pub async fn get_daemon_runtime_config(
-    daemon: State<'_, Daemon>,
-) -> Result<DaemonRuntimeConfigResponse, String> {
-    let status = daemon
-        .status()
-        .await
-        .map_err(|e| format!("Failed to get status: {e}"))?;
-
-    Ok(DaemonRuntimeConfigResponse {
-        server_address: status.listen_address,
-        tlsforward_enabled: status.tlsforward_enabled,
-    })
-}
-
-#[tauri::command]
-pub async fn get_tlsforward_status(
-    daemon: State<'_, Daemon>,
-) -> Result<gate_daemon::TlsForwardStatus, String> {
-    let status = daemon
-        .status()
-        .await
-        .map_err(|e| format!("Failed to get status: {e}"))?;
-    Ok(status.tlsforward_status)
-}
-
-#[tauri::command]
-pub async fn configure_tlsforward(
-    daemon: State<'_, Daemon>,
-    enabled: bool,
-    server_address: Option<String>,
-) -> Result<String, String> {
-    // Get current config
-    let mut config = daemon
-        .get_settings()
-        .await
-        .map_err(|e| format!("Failed to get config: {e}"))?;
-
-    // Update TLS forward config
-    config.tlsforward.enabled = enabled;
-    if let Some(addr) = server_address {
-        config.tlsforward.tlsforward_addresses = vec![addr];
-    }
-
-    // Update daemon config
-    daemon
-        .system_identity()
-        .update_config(config)
-        .await
-        .map_err(|e| format!("Failed to update config: {e}"))?;
-
-    Ok("TLS forward configuration updated".to_string())
-}
-
-#[tauri::command]
-pub async fn enable_tlsforward(daemon: State<'_, Daemon>) -> Result<String, String> {
-    configure_tlsforward(daemon, true, None).await
-}
-
-#[tauri::command]
-pub async fn disable_tlsforward(daemon: State<'_, Daemon>) -> Result<String, String> {
-    configure_tlsforward(daemon, false, None).await
-}
-
-#[tauri::command]
-pub async fn get_bootstrap_url(daemon: State<'_, Daemon>) -> Result<Option<String>, String> {
-    daemon
-        .bootstrap_url()
-        .await
-        .map_err(|e| format!("Failed to get bootstrap URL: {e}"))
-}
-
-#[tauri::command]
-pub async fn get_bootstrap_token(daemon: State<'_, Daemon>) -> Result<Option<String>, String> {
-    Ok(daemon
-        .get_bootstrap_manager()
-        .await
-        .map_err(|e| format!("Failed to get bootstrap manager: {e}"))?
-        .get_token()
-        .await)
-}
diff --git a/crates/gui/src/main.rs b/crates/gui/src/main.rs
deleted file mode 100644
index f4781a8d..00000000
--- a/crates/gui/src/main.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-#![cfg_attr(
-    all(not(debug_assertions), target_os = "windows"),
-    windows_subsystem = "windows"
-)]
-
-#[macro_use]
-extern crate tracing;
-
-mod commands;
-
-use gate_core::tracing::{
-    config::{InstrumentationConfig, OtlpConfig},
-    init::init_tracing,
-};
-use gate_daemon::Daemon;
-use tauri::Manager;
-
-fn main() {
-    // Initialize rustls crypto provider for TLS connections
-    rustls::crypto::ring::default_provider()
-        .install_default()
-        .expect("Failed to install rustls crypto provider");
-
-    // Initialize instrumentation
-    let instrumentation_config = InstrumentationConfig {
-        service_name: "gate-gui".to_string(),
-        service_version: env!("CARGO_PKG_VERSION").to_string(),
-        log_level: std::env::var("RUST_LOG")
-            .unwrap_or_else(|_| "gate=debug,tower_http=debug".to_string()),
-        otlp: std::env::var("OTLP_ENDPOINT")
-            .ok()
-            .map(|endpoint| OtlpConfig {
-                endpoint,
-                headers: None,
-            }),
-    };
-    init_tracing(&instrumentation_config).expect("Failed to initialize tracing");
-
-    tauri::Builder::default()
-        .plugin(tauri_plugin_opener::init())
-        .invoke_handler(tauri::generate_handler![
-            commands::start_daemon,
-            commands::stop_daemon,
-            commands::daemon_status,
-            commands::get_daemon_config,
-            commands::restart_daemon,
-            commands::get_daemon_status,
-            commands::get_daemon_runtime_config,
-            commands::get_tlsforward_status,
-            commands::configure_tlsforward,
-            commands::enable_tlsforward,
-            commands::disable_tlsforward,
-            commands::get_bootstrap_url,
-            commands::get_bootstrap_token,
-        ])
-        .on_window_event(|window, event| {
-            if let tauri::WindowEvent::CloseRequested { .. } = event {
-                // Get the app handle from the window
-                let app = window.app_handle();
-                if let Some(daemon) = app.try_state::<Option<Daemon>>() {
-                    if daemon.is_some() {
-                        tracing::info!("Stopping daemon on window close");
-                        let _ = tauri::async_runtime::block_on(commands::stop_daemon(daemon));
-                    } else {
-                        tracing::warn!("No daemon instance found on window close");
-                    }
-                }
-            }
-        })
-        .setup(|app| {
-            // Optionally start the daemon automatically on app launch
-            let handle = app.handle().clone();
-            tauri::async_runtime::spawn(async move {
-                // // Wait a moment for the app to fully initialize
-                match commands::start_daemon(handle.clone()).await {
-                    Ok(msg) => tracing::info!("{}", msg),
-                    Err(e) => tracing::error!("Failed to auto-start daemon: {}", e),
-                }
-            });
-            Ok(())
-        })
-        .run(tauri::generate_context!())
-        .expect("error while running tauri application");
-}
diff --git a/crates/gui/tauri.conf.json b/crates/gui/tauri.conf.json
deleted file mode 100644
index a69d7ce8..00000000
--- a/crates/gui/tauri.conf.json
+++ /dev/null
@@ -1,45 +0,0 @@
-{
-  "productName": "Gate",
-  "version": "0.1.0",
-  "identifier": "ai.hellas.gate",
-  "build": {
-    "frontendDist": "../frontend-tauri/dist",
-    "devUrl": "http://localhost:8082",
-    "beforeDevCommand": "sh -c 'cd frontend-tauri && trunk serve'",
-    "beforeBuildCommand": "echo 'DEBUG: PWD before cd:' && pwd && echo 'DEBUG: Contents of current dir:' && ls -la && echo 'DEBUG: Attempting cd to frontend-daemon' && cd frontend-daemon && pwd && trunk build --release && cd ../frontend-tauri && pwd && trunk build --release"
-  },
-  "app": {
-    "withGlobalTauri": true,
-    "windows": [
-      {
-        "title": "Hellas Gate",
-        "width": 400,
-        "height": 600,
-        "resizable": false
-      }
-    ],
-    "security": {
-      "csp": null,
-      "dangerousDisableAssetCspModification": true
-    }
-  },
-  "bundle": {
-    "active": true,
-    "targets": "all",
-    "icon": [
-      "icons/32x32.png",
-      "icons/128x128.png",
-      "icons/128x128@2x.png",
-      "icons/icon.icns",
-      "icons/icon.ico"
-    ],
-    "resources": {
-      "resources/frontend-daemon/": "frontend-daemon/"
-    },
-    "macOS": {
-      "entitlements": "./entitlements.plist",
-      "hardenedRuntime": true
-    }
-  },
-  "plugins": {}
-}
\ No newline at end of file
diff --git a/crates/http/Cargo.toml b/crates/http/Cargo.toml
deleted file mode 100644
index f94526de..00000000
--- a/crates/http/Cargo.toml
+++ /dev/null
@@ -1,80 +0,0 @@
-[package]
-name = "gate-http"
-version.workspace = true
-edition.workspace = true
-authors.workspace = true
-license.workspace = true
-repository.workspace = true
-keywords.workspace = true
-categories.workspace = true
-
-[features]
-default = ["server"]
-otlp = ["gate-core/tracing-otlp", "gate-core/tracing-prometheus"]
-server = [
-    "dep:anyhow",
-    "dep:async-trait",
-    "dep:axum",
-    "dep:base64",
-    "dep:bytes",
-    "dep:chrono",
-    "dep:futures",
-    "dep:gate-core",
-    "dep:getrandom",
-    "dep:http",
-    "dep:hyper",
-    "dep:hyper-util",
-    "dep:jsonwebtoken",
-    "dep:rand",
-    "dep:reqwest",
-    "dep:sha2",
-    "dep:tokio",
-    "dep:tower",
-    "dep:tower-http",
-    "dep:uuid",
-    "dep:webauthn-rs"
-]
-client = ["dep:reqwest", "dep:gate-core"]
-
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-hyper-util = { workspace = true, features = ["server", "tokio"], optional = true }
-jsonwebtoken = { version = "9.3", optional = true }
-reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls", "stream", "zstd", "brotli", "gzip", "deflate"], optional = true }
-webauthn-rs = { version = "0.5", optional = true }
-
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-getrandom = { workspace = true, features = ["wasm_js"], optional = true }
-hyper-util = { workspace = true, features = ["server"], optional = true }
-reqwest = { version = "0.12", default-features = false, features = ["json", "stream"], optional = true }
-
-[dependencies]
-anyhow = { workspace = true, optional = true }
-async-trait = { workspace = true, optional = true }
-axum = { workspace = true, optional = true }
-base64 = { workspace = true, optional = true }
-bytes = { workspace = true, optional = true }
-chrono = { workspace = true, optional = true }
-futures = { workspace = true, optional = true }
-gate-core = { workspace = true, features = ["tracing"], optional = true }
-http = { workspace = true, optional = true }
-opentelemetry = { version = "0.32", default-features = false, features = ["trace"] }
-hyper = { workspace = true, optional = true }
-rand = { workspace = true, optional = true }
-rust_decimal = { workspace = true }
-serde.workspace = true
-serde_json.workspace = true
-sha2 = { workspace = true, optional = true }
-thiserror.workspace = true
-tokio = { workspace = true, optional = true }
-tower = { workspace = true, features = ["util"], optional = true }
-tower-http = { workspace = true, optional = true }
-tracing = { workspace = true }
-uuid = { version = "1", features = ["v4", "serde", "js"], optional = true }
-url = { workspace = true }
-
-[dev-dependencies]
-gate-core = { workspace = true, features = ["tests"] }
-tokio = { workspace = true, features = ["full"] }
-tracing-subscriber = { workspace = true }
-wiremock = { workspace = true }
-http-body-util = "0.1"
diff --git a/crates/http/README.md b/crates/http/README.md
deleted file mode 100644
index 69ec3f78..00000000
--- a/crates/http/README.md
+++ /dev/null
@@ -1,87 +0,0 @@
-# gate-http
-
-HTTP layer for Gate, providing OpenAI/Anthropic-compatible API routing, middleware, and client functionality. Built on Axum for the server and reqwest for the client.
-
-## Responsibilities
-
-- **API Routes**: OpenAI/Anthropic compatible endpoints (`/v1/chat/completions`, `/v1/messages`)
-- **Middleware**: Authentication, tracing, WebAuthn support
-- **Request Forwarding**: Routes requests to upstream providers (OpenAI, Anthropic, etc.)
-- **Client Library**: Type-safe client for Gate APIs
-
-## Organization
-
-```
-src/
-├── routes/          # API endpoint handlers
-│   ├── inference    # Chat completion & messages endpoints
-│   ├── models       # Model listing endpoints
-│   └── dashboard    # User management APIs
-├── middleware/      # Request processing pipeline
-├── forwarding.rs    # Upstream provider integration
-├── client/          # Client library (feature = "client")
-└── services/        # Business logic (auth, JWT, WebAuthn)
-```
-
-## Features
-
-- `default`: Server functionality
-- `server`: Full HTTP server with all dependencies
-- `client`: Lightweight client library only
-
-## Key Components
-
-### AppState
-Central application state containing:
-- `StateBackend` implementation
-- `UpstreamRegistry` for provider routing
-- Plugin manager
-- Configuration
-
-### UpstreamRegistry
-Manages upstream AI providers:
-```rust
-registry.register("openai", OpenAIProvider::new(config));
-registry.route(request) // Returns appropriate provider
-```
-
-### Middleware Pipeline
-1. **Tracing**: Request/response logging with correlation IDs
-2. **Authentication**: API key validation via `StateBackend`
-3. **WebAuthn**: Hardware authentication support
-
-## Usage
-
-### Server
-```rust
-use gate_http::{server::create_router, AppState};
-
-let state = AppState::new(backend, config);
-let app = create_router(state);
-// Serve with axum::serve
-```
-
-### Client
-```rust
-use gate_http::client::GateClient;
-
-let client = GateClient::new("https://api.gate.ai", "gk-xxx");
-let response = client.chat_completion(request).await?;
-```
-
-## Dependencies
-
-Server (heavy):
-- `axum`, `tower`, `hyper`: HTTP server stack
-- `webauthn-rs`: Hardware auth (native only)
-- `jsonwebtoken`: JWT handling
-
-Client (minimal):
-- `reqwest`: HTTP client
-- `serde_json`: Request/response serialization
-
-## Risks
-
-- **Provider Changes**: Upstream API changes require updates to forwarding logic
-- **WASM Limitations**: WebAuthn not available in WASM builds
-- **Breaking Changes**: Route changes affect all Gate deployments
\ No newline at end of file
diff --git a/crates/http/src/auth/identity_extractor.rs b/crates/http/src/auth/identity_extractor.rs
deleted file mode 100644
index fc91c72a..00000000
--- a/crates/http/src/auth/identity_extractor.rs
+++ /dev/null
@@ -1,190 +0,0 @@
-//! Extract identity from HTTP headers
-
-use axum::http::HeaderMap;
-use http::HeaderName;
-use http::header::AUTHORIZATION;
-const X_API_KEY: HeaderName = HeaderName::from_static("x-api-key");
-const X_USER_ID: HeaderName = HeaderName::from_static("x-user-id");
-const X_ORG_ID: HeaderName = HeaderName::from_static("x-org-id");
-use gate_core::access::SubjectIdentity;
-use gate_core::router::sink::RouterIdentityContext;
-use sha2::Digest;
-
-/// Extract identity from request headers
-pub fn extract_identity(headers: &HeaderMap) -> SubjectIdentity<RouterIdentityContext> {
-    // Check for Authorization header
-    if let Some(auth_header) = headers.get(AUTHORIZATION)
-        && let Ok(auth_str) = auth_header.to_str()
-    {
-        return parse_authorization_header(auth_str);
-    }
-
-    // Check for X-API-Key header
-    if let Some(api_key) = headers.get(X_API_KEY)
-        && let Ok(key_str) = api_key.to_str()
-    {
-        return create_api_key_identity(key_str);
-    }
-
-    // Check for X-User-ID header (for internal services)
-    if let Some(user_id) = headers.get(X_USER_ID)
-        && let Ok(user_str) = user_id.to_str()
-    {
-        let org_id = headers
-            .get(X_ORG_ID)
-            .and_then(|v| v.to_str().ok())
-            .map(String::from);
-
-        return SubjectIdentity::new(
-            user_str,
-            "internal",
-            RouterIdentityContext {
-                org_id,
-                user_id: Some(user_str.to_string()),
-                api_key_hash: None,
-            },
-        );
-    }
-
-    // Default to anonymous
-    SubjectIdentity::new("anonymous", "http", RouterIdentityContext::default())
-}
-
-fn parse_authorization_header(auth_str: &str) -> SubjectIdentity<RouterIdentityContext> {
-    let parts: Vec<&str> = auth_str.splitn(2, ' ').collect();
-
-    match parts.as_slice() {
-        ["Bearer", token] => parse_bearer_token(token),
-        ["Basic", credentials] => parse_basic_auth(credentials),
-        ["ApiKey", key] => create_api_key_identity(key),
-        _ => {
-            // Unknown auth type
-            SubjectIdentity::new("unknown", "http", RouterIdentityContext::default())
-        }
-    }
-}
-
-fn parse_bearer_token(token: &str) -> SubjectIdentity<RouterIdentityContext> {
-    // In a real implementation, we would validate the JWT token
-    // and extract claims. For now, we'll create a simple identity
-
-    // Hash the token for the identity ID (in production, validate and extract sub claim)
-    use sha2::Sha256;
-    let mut hasher = Sha256::new();
-    hasher.update(token.as_bytes());
-    let token_hash = format!("{:x}", hasher.finalize());
-
-    SubjectIdentity::new(
-        &token_hash[..8], // Use first 8 chars of hash as ID
-        "bearer",
-        RouterIdentityContext {
-            org_id: None,  // Would be extracted from JWT claims
-            user_id: None, // Would be extracted from JWT claims
-            api_key_hash: None,
-        },
-    )
-}
-
-fn parse_basic_auth(credentials: &str) -> SubjectIdentity<RouterIdentityContext> {
-    // Decode base64
-    use base64::{Engine as _, engine::general_purpose};
-    if let Ok(decoded) = general_purpose::STANDARD.decode(credentials)
-        && let Ok(decoded_str) = String::from_utf8(decoded)
-    {
-        let parts: Vec<&str> = decoded_str.splitn(2, ':').collect();
-        if parts.len() == 2 {
-            let username = parts[0];
-            // In production, would validate password
-
-            return SubjectIdentity::new(
-                username,
-                "basic",
-                RouterIdentityContext {
-                    org_id: None,
-                    user_id: Some(username.to_string()),
-                    api_key_hash: None,
-                },
-            );
-        }
-    }
-
-    SubjectIdentity::new("invalid_basic", "http", RouterIdentityContext::default())
-}
-
-fn create_api_key_identity(api_key: &str) -> SubjectIdentity<RouterIdentityContext> {
-    use sha2::{Digest, Sha256};
-
-    // Hash the API key
-    let mut hasher = Sha256::new();
-    hasher.update(api_key.as_bytes());
-    let hash_result = hasher.finalize();
-    let api_key_hash = format!("{hash_result:x}");
-
-    // Use first 8 chars of hash as identity ID
-    SubjectIdentity::new(
-        &api_key_hash[..8],
-        "api_key",
-        RouterIdentityContext {
-            org_id: None,  // Would be looked up from database
-            user_id: None, // Would be looked up from database
-            api_key_hash: Some(api_key_hash.clone()),
-        },
-    )
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_extract_anonymous() {
-        let headers = HeaderMap::new();
-        let identity = extract_identity(&headers);
-        assert_eq!(identity.id, "anonymous");
-        assert_eq!(identity.source, "http");
-    }
-
-    #[test]
-    fn test_extract_api_key() {
-        let mut headers = HeaderMap::new();
-        headers.insert("x-api-key", "test-key-123".parse().unwrap());
-
-        let identity = extract_identity(&headers);
-        assert_eq!(identity.source, "api_key");
-        assert!(identity.context.api_key_hash.is_some());
-    }
-
-    #[test]
-    fn test_extract_bearer_token() {
-        let mut headers = HeaderMap::new();
-        headers.insert("authorization", "Bearer some-jwt-token".parse().unwrap());
-
-        let identity = extract_identity(&headers);
-        assert_eq!(identity.source, "bearer");
-    }
-
-    #[test]
-    fn test_extract_basic_auth() {
-        let mut headers = HeaderMap::new();
-        // "user:pass" in base64
-        headers.insert("authorization", "Basic dXNlcjpwYXNz".parse().unwrap());
-
-        let identity = extract_identity(&headers);
-        assert_eq!(identity.source, "basic");
-        assert_eq!(identity.id, "user");
-        assert_eq!(identity.context.user_id, Some("user".to_string()));
-    }
-
-    #[test]
-    fn test_extract_internal_headers() {
-        let mut headers = HeaderMap::new();
-        headers.insert("x-user-id", "user123".parse().unwrap());
-        headers.insert("x-org-id", "org456".parse().unwrap());
-
-        let identity = extract_identity(&headers);
-        assert_eq!(identity.source, "internal");
-        assert_eq!(identity.id, "user123");
-        assert_eq!(identity.context.user_id, Some("user123".to_string()));
-        assert_eq!(identity.context.org_id, Some("org456".to_string()));
-    }
-}
diff --git a/crates/http/src/auth/mod.rs b/crates/http/src/auth/mod.rs
deleted file mode 100644
index 166bc5ed..00000000
--- a/crates/http/src/auth/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-//! Authentication and identity extraction
-
-pub mod identity_extractor;
-
-pub use identity_extractor::extract_identity;
diff --git a/crates/http/src/client/auth.rs b/crates/http/src/client/auth.rs
deleted file mode 100644
index f10929ed..00000000
--- a/crates/http/src/client/auth.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-//! Authentication API client methods
-
-use super::{ClientError, GateClient};
-use crate::types::{
-    AuthCompleteRequest, AuthCompleteResponse, AuthStartResponse, RegisterCompleteRequest,
-    RegisterCompleteResponse, RegisterStartRequest, RegisterStartResponse,
-};
-
-impl GateClient {
-    /// Start WebAuthn registration
-    pub async fn register_start(&self, name: String) -> Result<RegisterStartResponse, ClientError> {
-        let req = self
-            .request(reqwest::Method::POST, "/auth/webauthn/register/start")?
-            .json(&RegisterStartRequest { name });
-        self.execute(req).await
-    }
-
-    /// Complete WebAuthn registration
-    pub async fn register_complete(
-        &self,
-        request: RegisterCompleteRequest,
-    ) -> Result<RegisterCompleteResponse, ClientError> {
-        let req = self
-            .request(reqwest::Method::POST, "/auth/webauthn/register/complete")?
-            .json(&request);
-        self.execute(req).await
-    }
-
-    /// Start WebAuthn authentication
-    pub async fn auth_start(&self) -> Result<AuthStartResponse, ClientError> {
-        let req = self.request(reqwest::Method::POST, "/auth/webauthn/authenticate/start")?;
-        self.execute(req).await
-    }
-
-    /// Complete WebAuthn authentication
-    pub async fn auth_complete(
-        &self,
-        request: AuthCompleteRequest,
-    ) -> Result<AuthCompleteResponse, ClientError> {
-        let req = self
-            .request(
-                reqwest::Method::POST,
-                "/auth/webauthn/authenticate/complete",
-            )?
-            .json(&request);
-        self.execute(req).await
-    }
-}
diff --git a/crates/http/src/client/auth_typed.rs b/crates/http/src/client/auth_typed.rs
deleted file mode 100644
index 83920328..00000000
--- a/crates/http/src/client/auth_typed.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-//! Type-safe authentication client extensions
-
-use super::{
-    error::ClientError,
-    typed::{AuthenticatedGateClient, PublicGateClient},
-};
-use crate::types::{
-    AuthCompleteRequest, AuthCompleteResponse, AuthStartResponse, RegisterCompleteRequest,
-    RegisterCompleteResponse, RegisterStartRequest, RegisterStartResponse,
-};
-use serde::{Deserialize, Serialize};
-
-/// Authentication endpoints for public client
-impl PublicGateClient {
-    /// Start WebAuthn registration (public endpoint)
-    pub async fn register_start(
-        &self,
-        request: RegisterStartRequest,
-    ) -> Result<RegisterStartResponse, ClientError> {
-        let req = self
-            .request(reqwest::Method::POST, "/auth/webauthn/register/start")?
-            .json(&request);
-        self.execute(req).await
-    }
-
-    /// Complete WebAuthn registration (public endpoint)
-    pub async fn register_complete(
-        &self,
-        request: RegisterCompleteRequest,
-    ) -> Result<RegisterCompleteResponse, ClientError> {
-        let req = self
-            .request(reqwest::Method::POST, "/auth/webauthn/register/complete")?
-            .json(&request);
-        self.execute(req).await
-    }
-
-    /// Complete WebAuthn registration with bootstrap token (daemon-specific endpoint)
-    pub async fn register_bootstrap(
-        &self,
-        request: RegisterCompleteRequest,
-    ) -> Result<RegisterCompleteResponse, ClientError> {
-        let req = self
-            .request(reqwest::Method::POST, "/auth/webauthn/register/bootstrap")?
-            .json(&request);
-        self.execute(req).await
-    }
-
-    /// Start WebAuthn authentication (public endpoint)
-    pub async fn auth_start(&self) -> Result<AuthStartResponse, ClientError> {
-        let req = self.request(reqwest::Method::POST, "/auth/webauthn/authenticate/start")?;
-        self.execute(req).await
-    }
-
-    /// Complete WebAuthn authentication (public endpoint)
-    pub async fn auth_complete(
-        &self,
-        request: AuthCompleteRequest,
-    ) -> Result<AuthCompleteResponse, ClientError> {
-        let req = self
-            .request(
-                reqwest::Method::POST,
-                "/auth/webauthn/authenticate/complete",
-            )?
-            .json(&request);
-        self.execute(req).await
-    }
-}
-
-/// Authentication endpoints for authenticated client
-impl AuthenticatedGateClient {
-    /// Get current user info (requires authentication)
-    pub async fn get_me(&self) -> Result<UserResponse, ClientError> {
-        let request = self.request(reqwest::Method::GET, "/api/auth/me")?;
-        self.execute(request).await
-    }
-}
-
-// Response types
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct UserResponse {
-    pub id: String,
-    pub name: Option<String>,
-    pub created_at: String,
-    pub updated_at: String,
-}
diff --git a/crates/http/src/client/config.rs b/crates/http/src/client/config.rs
deleted file mode 100644
index d0795a83..00000000
--- a/crates/http/src/client/config.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//! Configuration management client methods
-
-use crate::client::{ClientError, GateClient};
-use crate::types::{ConfigPatchRequest, ConfigResponse, ConfigUpdateRequest};
-use reqwest::Method;
-use serde_json::Value;
-
-impl GateClient {
-    /// Get the full configuration
-    pub async fn get_config(&self) -> Result<ConfigResponse, ClientError> {
-        let request = self.request(Method::GET, "/api/config")?;
-        self.execute(request).await
-    }
-
-    /// Get configuration at a specific path
-    pub async fn get_config_path(&self, path: &str) -> Result<Value, ClientError> {
-        let request = self.request(Method::GET, &format!("/api/config/{path}"))?;
-        self.execute(request).await
-    }
-
-    /// Update the full configuration
-    pub async fn update_config(&self, config: Value) -> Result<ConfigResponse, ClientError> {
-        let request = self
-            .request(Method::PUT, "/api/config")?
-            .json(&ConfigUpdateRequest { config });
-        self.execute(request).await
-    }
-
-    /// Update configuration at a specific path
-    pub async fn patch_config_path(&self, path: &str, value: Value) -> Result<Value, ClientError> {
-        let request = self
-            .request(Method::PATCH, &format!("/api/config/{path}"))?
-            .json(&ConfigPatchRequest { value });
-        self.execute(request).await
-    }
-}
diff --git a/crates/http/src/client/error.rs b/crates/http/src/client/error.rs
deleted file mode 100644
index 966f2de7..00000000
--- a/crates/http/src/client/error.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-//! Client error types
-
-use thiserror::Error;
-
-/// Client error types
-#[derive(Debug, Error)]
-pub enum ClientError {
-    /// Network or request error
-    #[error("Request failed: {0}")]
-    Request(#[from] reqwest::Error),
-
-    /// Server returned an error status
-    #[error("Server error {status}: {message}")]
-    ServerError { status: u16, message: String },
-
-    /// Authentication failed
-    #[error("Authentication failed: {0}")]
-    AuthenticationFailed(String),
-
-    /// Resource not found
-    #[error("Resource not found: {0}")]
-    NotFound(String),
-
-    /// Bad request
-    #[error("Bad request: {0}")]
-    BadRequest(String),
-
-    /// Forbidden
-    #[error("Forbidden: {0}")]
-    Forbidden(String),
-
-    /// Serialization/deserialization error
-    #[error("Serialization error: {0}")]
-    Serialization(#[from] serde_json::Error),
-
-    /// Invalid configuration
-    #[error("Invalid configuration: {0}")]
-    Configuration(String),
-}
-
-impl ClientError {
-    /// Create error from HTTP status code
-    pub fn from_status(status: reqwest::StatusCode, message: String) -> Self {
-        match status.as_u16() {
-            400 => Self::BadRequest(message),
-            401 => Self::AuthenticationFailed(message),
-            403 => Self::Forbidden(message),
-            404 => Self::NotFound(message),
-            _ => Self::ServerError {
-                status: status.as_u16(),
-                message,
-            },
-        }
-    }
-
-    /// Check if this is an authentication error that requires re-authentication
-    pub fn is_auth_expired(&self) -> bool {
-        match self {
-            Self::AuthenticationFailed(_) => true, // All 401 errors should trigger re-auth
-            _ => false,
-        }
-    }
-}
diff --git a/crates/http/src/client/inference.rs b/crates/http/src/client/inference.rs
deleted file mode 100644
index 6b736dcf..00000000
--- a/crates/http/src/client/inference.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-//! Inference API client methods
-
-use super::{ClientError, GateClient};
-use crate::types::{
-    AnthropicMessagesRequest, OpenAIChatCompletionRequest, OpenAICompletionRequest,
-};
-use serde_json::Value as JsonValue;
-
-impl GateClient {
-    /// Send an Anthropic Messages API request
-    pub async fn messages(
-        &self,
-        request: AnthropicMessagesRequest,
-    ) -> Result<JsonValue, ClientError> {
-        let req = self
-            .request(reqwest::Method::POST, "/v1/messages")?
-            .json(&request);
-        self.execute(req).await
-    }
-
-    /// Send an OpenAI Chat Completions API request
-    pub async fn chat_completions(
-        &self,
-        request: OpenAIChatCompletionRequest,
-    ) -> Result<JsonValue, ClientError> {
-        let req = self
-            .request(reqwest::Method::POST, "/v1/chat/completions")?
-            .json(&request);
-        self.execute(req).await
-    }
-
-    /// Send an OpenAI Completions API request (legacy)
-    pub async fn completions(
-        &self,
-        request: OpenAICompletionRequest,
-    ) -> Result<JsonValue, ClientError> {
-        let req = self
-            .request(reqwest::Method::POST, "/v1/completions")?
-            .json(&request);
-        self.execute(req).await
-    }
-}
diff --git a/crates/http/src/client/inference_typed.rs b/crates/http/src/client/inference_typed.rs
deleted file mode 100644
index 56f114bd..00000000
--- a/crates/http/src/client/inference_typed.rs
+++ /dev/null
@@ -1,149 +0,0 @@
-//! Type-safe inference client extensions
-
-use super::{error::ClientError, typed::AuthenticatedGateClient};
-use serde::{Deserialize, Serialize};
-
-/// Inference endpoints for authenticated client
-impl AuthenticatedGateClient {
-    /// List available models (requires authentication)
-    pub async fn list_models(&self) -> Result<ModelsResponse, ClientError> {
-        let request = self.request(reqwest::Method::GET, "/v1/models")?;
-        self.execute(request).await
-    }
-
-    /// Get model details (requires authentication)
-    pub async fn get_model(&self, model_id: &str) -> Result<ModelResponse, ClientError> {
-        let request = self.request(reqwest::Method::GET, &format!("/v1/models/{model_id}"))?;
-        self.execute(request).await
-    }
-
-    /// Create a chat completion (requires authentication)
-    pub async fn create_chat_completion(
-        &self,
-        request: ChatCompletionRequest,
-    ) -> Result<ChatCompletionResponse, ClientError> {
-        let req = self
-            .request(reqwest::Method::POST, "/v1/chat/completions")?
-            .json(&request);
-        self.execute(req).await
-    }
-
-    /// Create a message (Anthropic-style, requires authentication)
-    pub async fn create_message(
-        &self,
-        request: MessageRequest,
-    ) -> Result<MessageResponse, ClientError> {
-        let req = self
-            .request(reqwest::Method::POST, "/v1/messages")?
-            .json(&request);
-        self.execute(req).await
-    }
-}
-
-// Request/Response types
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ModelsResponse {
-    pub object: String,
-    pub data: Vec<Model>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Model {
-    pub id: String,
-    pub object: String,
-    pub created: i64,
-    pub owned_by: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ModelResponse {
-    pub id: String,
-    pub object: String,
-    pub created: i64,
-    pub owned_by: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ChatCompletionRequest {
-    pub model: String,
-    pub messages: Vec<ChatMessage>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub temperature: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_tokens: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub stream: Option<bool>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ChatMessage {
-    pub role: String,
-    pub content: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ChatCompletionResponse {
-    pub id: String,
-    pub object: String,
-    pub created: i64,
-    pub model: String,
-    pub choices: Vec<ChatChoice>,
-    pub usage: Option<Usage>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ChatChoice {
-    pub index: u32,
-    pub message: ChatMessage,
-    pub finish_reason: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Usage {
-    pub prompt_tokens: u32,
-    pub completion_tokens: u32,
-    pub total_tokens: u32,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct MessageRequest {
-    pub model: String,
-    pub messages: Vec<AnthropicMessage>,
-    pub max_tokens: u32,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub temperature: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub stream: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub system: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AnthropicMessage {
-    pub role: String,
-    pub content: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct MessageResponse {
-    pub id: String,
-    pub model: String,
-    pub role: String,
-    pub content: Vec<ContentBlock>,
-    pub stop_reason: Option<String>,
-    pub stop_sequence: Option<String>,
-    pub usage: AnthropicUsage,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ContentBlock {
-    #[serde(rename = "type")]
-    pub content_type: String,
-    pub text: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AnthropicUsage {
-    pub input_tokens: u32,
-    pub output_tokens: u32,
-}
diff --git a/crates/http/src/client/mod.rs b/crates/http/src/client/mod.rs
deleted file mode 100644
index 2a7c0859..00000000
--- a/crates/http/src/client/mod.rs
+++ /dev/null
@@ -1,145 +0,0 @@
-//! Gate HTTP client
-
-pub mod auth;
-pub mod auth_typed;
-pub mod config;
-pub mod error;
-pub mod inference;
-pub mod inference_typed;
-pub mod typed;
-
-use error::ClientError;
-use reqwest::{Client, ClientBuilder, Method, RequestBuilder, header};
-use std::time::Duration;
-use url::Url;
-
-pub use typed::{AuthenticatedGateClient, PublicGateClient, TypedClientBuilder};
-
-/// Gate API client
-#[derive(Clone)]
-pub struct GateClient {
-    client: Client,
-    base_url: Url,
-    api_key: Option<String>,
-}
-
-impl GateClient {
-    /// Create a new client with default configuration
-    pub fn new(base_url: impl Into<String>) -> Result<Self, ClientError> {
-        Self::builder().base_url(base_url).build()
-    }
-
-    /// Create a new client builder
-    pub fn builder() -> GateClientBuilder {
-        GateClientBuilder::default()
-    }
-
-    /// Get the base URL
-    pub fn base_url(&self) -> &Url {
-        &self.base_url
-    }
-
-    /// Create a request builder with authentication
-    pub fn request(&self, method: Method, path: &str) -> Result<RequestBuilder, ClientError> {
-        let url = self
-            .base_url
-            .join(path.trim_start_matches('/'))
-            .map_err(|e| ClientError::Configuration(format!("invalid path '{path}': {e}")))?;
-        let mut request = self.client.request(method, url);
-
-        if let Some(api_key) = &self.api_key {
-            request = request.header(header::AUTHORIZATION, format!("Bearer {api_key}"));
-        }
-
-        Ok(request)
-    }
-
-    /// Execute a request and handle common errors
-    pub async fn execute<T: serde::de::DeserializeOwned>(
-        &self,
-        request: reqwest::RequestBuilder,
-    ) -> Result<T, ClientError> {
-        let response = request.send().await?;
-        let status = response.status();
-
-        if status.is_success() {
-            Ok(response.json().await?)
-        } else {
-            let message = response.text().await.unwrap_or_else(|_| status.to_string());
-            Err(ClientError::from_status(status, message))
-        }
-    }
-}
-
-/// Builder for GateClient
-#[derive(Default)]
-pub struct GateClientBuilder {
-    base_url: Option<String>,
-    api_key: Option<String>,
-    timeout: Option<Duration>,
-    user_agent: Option<String>,
-}
-
-impl GateClientBuilder {
-    /// Set the base URL
-    pub fn base_url(mut self, url: impl Into<String>) -> Self {
-        self.base_url = Some(url.into());
-        self
-    }
-
-    /// Set the API key for authentication
-    pub fn api_key(mut self, key: impl Into<String>) -> Self {
-        self.api_key = Some(key.into());
-        self
-    }
-
-    /// Set the request timeout
-    pub fn timeout(mut self, timeout: Duration) -> Self {
-        self.timeout = Some(timeout);
-        self
-    }
-
-    /// Set the user agent
-    pub fn user_agent(mut self, agent: impl Into<String>) -> Self {
-        self.user_agent = Some(agent.into());
-        self
-    }
-
-    /// Build the client
-    pub fn build(self) -> Result<GateClient, ClientError> {
-        let base_url = self
-            .base_url
-            .ok_or_else(|| ClientError::Configuration("base_url is required".into()))?;
-
-        // Parse base_url into Url
-        let mut base_url = Url::parse(&base_url)
-            .map_err(|e| ClientError::Configuration(format!("invalid base_url: {e}")))?;
-        // Normalize path to avoid trailing slash issues
-        if base_url.path() != "/" && base_url.path().ends_with('/') {
-            base_url = base_url
-                .join(".")
-                .map_err(|e| ClientError::Configuration(format!("invalid base_url path: {e}")))?;
-        }
-
-        let mut client_builder = ClientBuilder::new();
-
-        #[cfg(not(target_arch = "wasm32"))]
-        if let Some(timeout) = self.timeout {
-            client_builder = client_builder.timeout(timeout);
-        }
-
-        if let Some(user_agent) = self.user_agent {
-            client_builder = client_builder.user_agent(user_agent);
-        } else {
-            client_builder = client_builder.user_agent("gate-client/0.1.0");
-        }
-
-        let client = client_builder.build()?;
-
-        Ok(GateClient {
-            client,
-            base_url,
-            api_key: self.api_key,
-        })
-    }
-}
diff --git a/crates/http/src/client/typed.rs b/crates/http/src/client/typed.rs
deleted file mode 100644
index 67fe2a93..00000000
--- a/crates/http/src/client/typed.rs
+++ /dev/null
@@ -1,246 +0,0 @@
-//! Type-safe API clients that enforce authentication requirements at compile time
-
-use super::ClientError;
-use reqwest::{Client, ClientBuilder, Method, RequestBuilder, header};
-use std::time::Duration;
-use url::Url;
-
-/// Client for public endpoints that don't require authentication
-#[derive(Clone)]
-pub struct PublicGateClient {
-    client: Client,
-    base_url: Url,
-}
-
-/// Client for authenticated endpoints that require a valid API key
-#[derive(Clone)]
-pub struct AuthenticatedGateClient {
-    client: Client,
-    base_url: Url,
-    api_key: String,
-}
-
-impl PublicGateClient {
-    /// Create a new public client
-    pub fn new(base_url: impl Into<String>) -> Result<Self, ClientError> {
-        Self::new_with_timeout(base_url, None)
-    }
-
-    /// Create a new public client with optional timeout
-    fn new_with_timeout(
-        base_url: impl Into<String>,
-        timeout: Option<Duration>,
-    ) -> Result<Self, ClientError> {
-        let mut base_url = Url::parse(&base_url.into())
-            .map_err(|e| ClientError::Configuration(format!("invalid base_url: {e}")))?;
-        if base_url.path() != "/" && base_url.path().ends_with('/') {
-            base_url = base_url
-                .join(".")
-                .map_err(|e| ClientError::Configuration(format!("invalid base_url path: {e}")))?;
-        }
-
-        #[cfg(not(target_arch = "wasm32"))]
-        let client = {
-            let mut builder = ClientBuilder::new().user_agent("gate-client/0.1.0");
-            if let Some(timeout) = timeout {
-                builder = builder.timeout(timeout);
-            }
-            builder.build()?
-        };
-
-        #[cfg(target_arch = "wasm32")]
-        let client = {
-            let _ = timeout; // Timeouts not supported on WASM
-            ClientBuilder::new()
-                .user_agent("gate-client/0.1.0")
-                .build()?
-        };
-
-        Ok(Self { client, base_url })
-    }
-
-    /// Get the base URL
-    pub fn base_url(&self) -> &Url {
-        &self.base_url
-    }
-
-    /// Create a request builder without authentication
-    pub fn request(&self, method: Method, path: &str) -> Result<RequestBuilder, ClientError> {
-        let url = self
-            .base_url
-            .join(path.trim_start_matches('/'))
-            .map_err(|e| ClientError::Configuration(format!("invalid path '{path}': {e}")))?;
-        Ok(self.client.request(method, url))
-    }
-
-    /// Execute a request and handle common errors
-    pub async fn execute<T: serde::de::DeserializeOwned>(
-        &self,
-        request: reqwest::RequestBuilder,
-    ) -> Result<T, ClientError> {
-        let response = request.send().await?;
-        let status = response.status();
-
-        if status.is_success() {
-            Ok(response.json().await?)
-        } else {
-            let message = response.text().await.unwrap_or_else(|_| status.to_string());
-            Err(ClientError::from_status(status, message))
-        }
-    }
-
-    /// Authenticate with an API key to get an authenticated client
-    pub fn authenticate(self, api_key: impl Into<String>) -> AuthenticatedGateClient {
-        AuthenticatedGateClient {
-            client: self.client,
-            base_url: self.base_url,
-            api_key: api_key.into(),
-        }
-    }
-}
-
-impl AuthenticatedGateClient {
-    /// Create a new authenticated client
-    pub fn new(
-        base_url: impl Into<String>,
-        api_key: impl Into<String>,
-    ) -> Result<Self, ClientError> {
-        Self::new_with_timeout(base_url, api_key, None)
-    }
-
-    /// Create a new authenticated client with optional timeout
-    fn new_with_timeout(
-        base_url: impl Into<String>,
-        api_key: impl Into<String>,
-        timeout: Option<Duration>,
-    ) -> Result<Self, ClientError> {
-        let mut base_url = Url::parse(&base_url.into())
-            .map_err(|e| ClientError::Configuration(format!("invalid base_url: {e}")))?;
-        if base_url.path() != "/" && base_url.path().ends_with('/') {
-            base_url = base_url
-                .join(".")
-                .map_err(|e| ClientError::Configuration(format!("invalid base_url path: {e}")))?;
-        }
-        let api_key = api_key.into();
-
-        #[cfg(not(target_arch = "wasm32"))]
-        let client = {
-            let mut builder = ClientBuilder::new().user_agent("gate-client/0.1.0");
-            if let Some(timeout) = timeout {
-                builder = builder.timeout(timeout);
-            }
-            builder.build()?
-        };
-
-        #[cfg(target_arch = "wasm32")]
-        let client = {
-            let _ = timeout; // Timeouts not supported on WASM
-            ClientBuilder::new()
-                .user_agent("gate-client/0.1.0")
-                .build()?
-        };
-
-        Ok(Self {
-            client,
-            base_url,
-            api_key,
-        })
-    }
-
-    /// Get the base URL
-    pub fn base_url(&self) -> &Url {
-        &self.base_url
-    }
-
-    /// Create a request builder with authentication
-    pub fn request(&self, method: Method, path: &str) -> Result<RequestBuilder, ClientError> {
-        let url = self
-            .base_url
-            .join(path.trim_start_matches('/'))
-            .map_err(|e| ClientError::Configuration(format!("invalid path '{path}': {e}")))?;
-        Ok(self
-            .client
-            .request(method, url)
-            .header(header::AUTHORIZATION, format!("Bearer {}", self.api_key)))
-    }
-
-    /// Execute a request and handle common errors
-    pub async fn execute<T: serde::de::DeserializeOwned>(
-        &self,
-        request: reqwest::RequestBuilder,
-    ) -> Result<T, ClientError> {
-        let response = request.send().await?;
-        let status = response.status();
-
-        if status.is_success() {
-            Ok(response.json().await?)
-        } else {
-            let message = response.text().await.unwrap_or_else(|_| status.to_string());
-            Err(ClientError::from_status(status, message))
-        }
-    }
-
-    /// Create a public client (useful for calling public endpoints)
-    pub fn to_public(&self) -> PublicGateClient {
-        PublicGateClient {
-            client: self.client.clone(),
-            base_url: self.base_url.clone(),
-        }
-    }
-}
-
-/// Type-safe builder that creates the appropriate client type
-pub struct TypedClientBuilder {
-    base_url: Option<String>,
-    timeout: Option<Duration>,
-}
-
-impl TypedClientBuilder {
-    /// Create a new builder
-    pub fn new() -> Self {
-        Self {
-            base_url: None,
-            timeout: None,
-        }
-    }
-
-    /// Set the base URL
-    pub fn base_url(mut self, url: impl Into<String>) -> Self {
-        self.base_url = Some(url.into());
-        self
-    }
-
-    /// Set the request timeout
-    #[cfg(not(target_arch = "wasm32"))]
-    pub fn timeout(mut self, timeout: Duration) -> Self {
-        self.timeout = Some(timeout);
-        self
-    }
-
-    /// Build a public client
-    pub fn build_public(self) -> Result<PublicGateClient, ClientError> {
-        let base_url = self
-            .base_url
-            .ok_or_else(|| ClientError::Configuration("base_url is required".into()))?;
-
-        PublicGateClient::new_with_timeout(base_url, self.timeout)
-    }
-
-    /// Build an authenticated client
-    pub fn build_authenticated(
-        self,
-        api_key: impl Into<String>,
-    ) -> Result<AuthenticatedGateClient, ClientError> {
-        let base_url = self
-            .base_url
-            .ok_or_else(|| ClientError::Configuration("base_url is required".into()))?;
-
-        AuthenticatedGateClient::new_with_timeout(base_url, api_key, self.timeout)
-    }
-}
-
-impl Default for TypedClientBuilder {
-    fn default() -> Self {
-        Self::new()
-    }
-}
diff --git a/crates/http/src/config/auth.rs b/crates/http/src/config/auth.rs
deleted file mode 100644
index b78a8ef7..00000000
--- a/crates/http/src/config/auth.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-//! Authentication configuration
-
-#[cfg(not(target_arch = "wasm32"))]
-use chrono::Duration;
-use serde::{Deserialize, Serialize};
-
-/// JWT configuration that can be serialized
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct JwtConfigData {
-    /// Secret key for signing tokens
-    pub secret: String,
-    /// Token expiration duration in seconds
-    pub expiration_seconds: i64,
-    /// Token issuer
-    pub issuer: String,
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-impl From<JwtConfigData> for crate::services::jwt::JwtConfig {
-    fn from(data: JwtConfigData) -> Self {
-        Self {
-            secret: data.secret,
-            expiration: Duration::seconds(data.expiration_seconds),
-            issuer: data.issuer,
-        }
-    }
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-impl From<crate::services::jwt::JwtConfig> for JwtConfigData {
-    fn from(config: crate::services::jwt::JwtConfig) -> Self {
-        Self {
-            secret: config.secret,
-            expiration_seconds: config.expiration.num_seconds(),
-            issuer: config.issuer,
-        }
-    }
-}
-
-/// Complete authentication configuration
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct AuthConfig {
-    /// JWT configuration
-    pub jwt: JwtConfigData,
-    /// Session configuration
-    pub session: SessionConfig,
-}
-
-/// Session configuration
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct SessionConfig {
-    /// Session timeout in seconds
-    pub timeout_seconds: u64,
-    /// Session cleanup interval in seconds
-    pub cleanup_interval_seconds: u64,
-}
-
-impl Default for SessionConfig {
-    fn default() -> Self {
-        Self {
-            timeout_seconds: 86400,         // 24 hours
-            cleanup_interval_seconds: 3600, // 1 hour
-        }
-    }
-}
diff --git a/crates/http/src/config/mod.rs b/crates/http/src/config/mod.rs
deleted file mode 100644
index e0d0399f..00000000
--- a/crates/http/src/config/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-//! Configuration module
-
-pub mod auth;
-
-pub use auth::AuthConfig;
diff --git a/crates/http/src/error.rs b/crates/http/src/error.rs
deleted file mode 100644
index f5846b2d..00000000
--- a/crates/http/src/error.rs
+++ /dev/null
@@ -1,123 +0,0 @@
-//! HTTP error types and implementations
-
-#[cfg(feature = "server")]
-use axum::{
-    Json,
-    http::StatusCode,
-    response::{IntoResponse, Response},
-};
-use serde::{Deserialize, Serialize};
-use thiserror::Error;
-
-/// HTTP-specific errors
-#[derive(Error, Debug)]
-pub enum HttpError {
-    /// Authentication failed
-    #[error("Authentication failed: {0}")]
-    AuthenticationFailed(String),
-
-    /// Authorization failed
-    #[error("Authorization failed: {0}")]
-    AuthorizationFailed(String),
-
-    /// Resource not found
-    #[error("Resource not found: {0}")]
-    NotFound(String),
-
-    /// Bad request
-    #[error("Bad request: {0}")]
-    BadRequest(String),
-
-    /// Internal server error
-    #[error("Internal server error: {0}")]
-    InternalServerError(String),
-
-    /// Service unavailable
-    #[error("Service unavailable: {0}")]
-    ServiceUnavailable(String),
-
-    /// Rate limit exceeded
-    #[error("Rate limit exceeded")]
-    RateLimitExceeded,
-
-    /// Conflict
-    #[error("Conflict: {0}")]
-    Conflict(String),
-
-    /// Unprocessable entity
-    #[error("Unprocessable entity: {0}")]
-    UnprocessableEntity(String),
-
-    /// Not implemented
-    #[error("Not implemented: {0}")]
-    NotImplemented(String),
-
-    /// Core error
-    #[error(transparent)]
-    Core(#[from] gate_core::Error),
-}
-
-/// Error response body
-#[derive(Debug, Serialize, Deserialize)]
-pub struct ErrorResponse {
-    pub error: String,
-    pub message: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub details: Option<serde_json::Value>,
-}
-
-#[cfg(feature = "server")]
-impl IntoResponse for HttpError {
-    fn into_response(self) -> Response {
-        let (status, error_type) = match &self {
-            HttpError::AuthenticationFailed(_) => {
-                (StatusCode::UNAUTHORIZED, "authentication_failed")
-            }
-            HttpError::AuthorizationFailed(_) => (StatusCode::FORBIDDEN, "authorization_failed"),
-            HttpError::NotFound(_) => (StatusCode::NOT_FOUND, "not_found"),
-            HttpError::BadRequest(_) => (StatusCode::BAD_REQUEST, "bad_request"),
-            HttpError::InternalServerError(_) => {
-                (StatusCode::INTERNAL_SERVER_ERROR, "internal_server_error")
-            }
-            HttpError::ServiceUnavailable(_) => {
-                (StatusCode::SERVICE_UNAVAILABLE, "service_unavailable")
-            }
-            HttpError::RateLimitExceeded => (StatusCode::TOO_MANY_REQUESTS, "rate_limit_exceeded"),
-            HttpError::Conflict(_) => (StatusCode::CONFLICT, "conflict"),
-            HttpError::UnprocessableEntity(_) => {
-                (StatusCode::UNPROCESSABLE_ENTITY, "unprocessable_entity")
-            }
-            HttpError::NotImplemented(_) => (StatusCode::from_u16(501).unwrap(), "not_implemented"),
-            HttpError::Core(core_err) => {
-                use gate_core::Error;
-                match core_err {
-                    Error::Rejected(status, _) => (*status, "upstream_error"),
-                    Error::Unauthorized => (StatusCode::FORBIDDEN, "unauthorized"),
-                    Error::ApiKeyNotFound | Error::InvalidApiKey => {
-                        (StatusCode::UNAUTHORIZED, "invalid_api_key")
-                    }
-                    Error::ModelNotFound(_) | Error::ProviderNotFound(_) => {
-                        (StatusCode::NOT_FOUND, "not_found")
-                    }
-                    Error::QuotaExceeded(_) => (StatusCode::TOO_MANY_REQUESTS, "quota_exceeded"),
-                    Error::InvalidRequest(_) => (StatusCode::BAD_REQUEST, "invalid_request"),
-                    Error::ServiceUnavailable(_) => {
-                        (StatusCode::SERVICE_UNAVAILABLE, "service_unavailable")
-                    }
-                    _ => (StatusCode::INTERNAL_SERVER_ERROR, "internal_server_error"),
-                }
-            }
-        };
-
-        let body = ErrorResponse {
-            error: error_type.to_string(),
-            message: self.to_string(),
-            details: None,
-        };
-
-        (status, Json(body)).into_response()
-    }
-}
-
-/// Result type alias using HttpError
-pub type Result<T> = std::result::Result<T, HttpError>;
diff --git a/crates/http/src/lib.rs b/crates/http/src/lib.rs
deleted file mode 100644
index 61c0b2dd..00000000
--- a/crates/http/src/lib.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-//! Gate HTTP module providing router and middleware functionality
-//!
-//! This module provides a flexible HTTP routing system with OpenAPI documentation support
-//! and extensible middleware framework for building API servers.
-
-#[cfg(feature = "server")]
-#[macro_use]
-extern crate tracing;
-
-pub mod error;
-pub mod types;
-
-#[cfg(feature = "server")]
-pub mod auth;
-#[cfg(feature = "server")]
-#[path = "config/mod.rs"]
-pub mod config;
-#[cfg(feature = "server")]
-pub mod middleware;
-#[cfg(feature = "server")]
-pub mod routes;
-#[cfg(feature = "server")]
-pub mod server;
-#[cfg(feature = "server")]
-pub mod services;
-#[cfg(feature = "server")]
-pub mod sinks;
-#[cfg(feature = "server")]
-pub mod state;
-#[cfg(feature = "server")]
-pub mod streaming;
-
-#[cfg(feature = "client")]
-pub mod client;
-
-pub use error::{HttpError, Result};
-
-#[cfg(feature = "server")]
-pub use state::AppState;
-
-// Re-export commonly used types
-#[cfg(feature = "server")]
-pub use axum::{Json, extract, response};
diff --git a/crates/http/src/middleware/auth.rs b/crates/http/src/middleware/auth.rs
deleted file mode 100644
index 5bf50b05..00000000
--- a/crates/http/src/middleware/auth.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-use crate::error::HttpError;
-use crate::services::identity::HttpIdentity;
-use async_trait::async_trait;
-use axum::{extract::Request, http::request::Parts, middleware::Next, response::Response};
-
-/// Trait for authentication providers
-#[async_trait]
-pub trait AuthProvider: Send + Sync {
-    /// Authenticate a request and return identity if successful
-    async fn authenticate(&self, parts: &Parts) -> Result<HttpIdentity, HttpError>;
-
-    /// Check if authentication should be skipped for a given path
-    fn should_skip_auth(&self, path: &str) -> bool {
-        path == "/health" || path.starts_with("/swagger-ui") || path == "/"
-    }
-}
-
-/// Middleware function for authentication
-pub async fn auth_middleware<T>(
-    axum::extract::State(app_state): axum::extract::State<crate::AppState<T>>,
-    req: Request,
-    next: Next,
-) -> Result<Response, HttpError>
-where
-    crate::AppState<T>: AuthProvider,
-    T: Clone + Send + Sync + 'static,
-{
-    let path = req.uri().path();
-
-    if app_state.should_skip_auth(path) {
-        return Ok(next.run(req).await);
-    }
-
-    let (mut parts, body) = req.into_parts();
-
-    match app_state.authenticate(&parts).await {
-        Ok(identity) => {
-            parts.extensions.insert(identity);
-            let req = Request::from_parts(parts, body);
-            Ok(next.run(req).await)
-        }
-        Err(e) => Err(e),
-    }
-}
-
-/// Blanket implementation for AppState<T> where T implements AuthProvider
-#[cfg(not(target_arch = "wasm32"))]
-#[async_trait]
-impl<T> AuthProvider for crate::AppState<T>
-where
-    T: AuthProvider + Clone + Send + Sync,
-{
-    async fn authenticate(&self, parts: &Parts) -> Result<HttpIdentity, HttpError> {
-        self.data.authenticate(parts).await
-    }
-
-    fn should_skip_auth(&self, path: &str) -> bool {
-        self.data.should_skip_auth(path)
-    }
-}
diff --git a/crates/http/src/middleware/correlation.rs b/crates/http/src/middleware/correlation.rs
deleted file mode 100644
index 690c9df3..00000000
--- a/crates/http/src/middleware/correlation.rs
+++ /dev/null
@@ -1,189 +0,0 @@
-//! Correlation ID middleware for request tracing
-//!
-//! This middleware extracts or generates correlation IDs for all requests,
-//! supporting both W3C TraceContext headers and legacy x-correlation-id.
-
-use axum::{
-    extract::Request,
-    http::{HeaderMap, HeaderName, HeaderValue},
-    middleware::Next,
-    response::IntoResponse,
-};
-use gate_core::tracing::{
-    prelude::*,
-    trace_context::{extract_trace_context, inject_trace_context},
-};
-
-/// Header name for legacy correlation ID
-pub const CORRELATION_ID_HEADER: &str = "x-correlation-id";
-/// W3C trace context header
-pub const TRACEPARENT_HEADER: &str = "traceparent";
-/// W3C trace state header
-pub const TRACESTATE_HEADER: &str = "tracestate";
-
-/// Extract or generate correlation ID from request headers
-///
-/// Priority:
-/// 1. W3C traceparent header
-/// 2. Legacy x-correlation-id header
-/// 3. Generate new
-pub fn extract_correlation_id(headers: &HeaderMap) -> CorrelationId {
-    // Try to extract W3C trace context first
-    if let Some(trace_context) = extract_trace_context(headers) {
-        return CorrelationId::from_trace_context(trace_context);
-    }
-
-    // Fallback to legacy correlation ID
-    headers
-        .get(CORRELATION_ID_HEADER)
-        .and_then(|v| v.to_str().ok())
-        .map(CorrelationId::from_legacy)
-        .unwrap_or_default()
-}
-
-/// Middleware to handle correlation IDs
-/// Middleware to handle correlation IDs
-#[allow(clippy::manual_async_fn)]
-pub fn correlation_id_middleware(
-    mut request: Request,
-    next: Next,
-) -> impl std::future::Future<Output = impl IntoResponse> + Send {
-    async move {
-        // Extract or generate correlation ID
-        let correlation_id = extract_correlation_id(request.headers());
-
-        // Add correlation ID to request extensions early so it's available to other middleware
-        request.extensions_mut().insert(correlation_id.clone());
-
-        // Set up the OpenTelemetry context and create span within it
-        #[cfg(all(feature = "otlp", not(target_arch = "wasm32")))]
-        {
-            use opentelemetry::{Context as OtelContext, trace::TraceContextExt};
-
-            // Create OpenTelemetry context with the remote span context
-            let span_context = correlation_id.to_span_context();
-            let _otel_context = OtelContext::current().with_remote_span_context(span_context);
-
-            // Create a span for this request with trace context information
-            let span = tracing::info_span!(
-                "http_request",
-                correlation_id = %correlation_id,
-                method = %request.method(),
-                path = %request.uri().path(),
-                otel.name = "http_request",
-                otel.kind = "SERVER",
-                // Include trace and span IDs for OpenTelemetry
-                trace_id = %correlation_id.trace_id(),
-                span_id = %correlation_id.span_id(),
-                // Include the traceparent header for propagation
-                traceparent = %correlation_id.to_traceparent()
-            );
-
-            // Process request with the span attached
-            // Note: When compiling with all features, we skip the context guard to avoid Send issues
-            // The span itself still provides the trace context for OpenTelemetry
-            let mut response = next.run(request).instrument(span).await;
-
-            // Add both W3C and legacy headers to response
-            let headers = response.headers_mut();
-
-            // Always inject W3C headers
-            if let Err(e) = inject_trace_context(correlation_id.trace_context(), headers) {
-                tracing::warn!("Failed to inject trace context headers: {}", e);
-            }
-
-            // Also add legacy header for backward compatibility
-            if let Ok(header_value) = HeaderValue::from_str(&correlation_id.to_string()) {
-                headers.insert(HeaderName::from_static(CORRELATION_ID_HEADER), header_value);
-            }
-
-            response
-        }
-
-        // Non-OTLP native path
-        #[cfg(all(not(feature = "otlp"), not(target_arch = "wasm32")))]
-        {
-            // Create a span for this request with trace context information
-            let span = tracing::info_span!(
-                "http_request",
-                correlation_id = %correlation_id,
-                method = %request.method(),
-                path = %request.uri().path(),
-                otel.name = "http_request",
-                otel.kind = "SERVER",
-                // Include trace and span IDs for OpenTelemetry
-                trace_id = %correlation_id.trace_id(),
-                span_id = %correlation_id.span_id(),
-                // Include the traceparent header for propagation
-                traceparent = %correlation_id.to_traceparent()
-            );
-
-            // Process request with the span attached
-            let mut response = next.run(request).instrument(span).await;
-
-            // Add both W3C and legacy headers to response
-            let headers = response.headers_mut();
-
-            // Always inject W3C headers
-            if let Err(e) = inject_trace_context(correlation_id.trace_context(), headers) {
-                tracing::warn!("Failed to inject trace context headers: {}", e);
-            }
-
-            // Also add legacy header for backward compatibility
-            if let Ok(header_value) = HeaderValue::from_str(&correlation_id.to_string()) {
-                headers.insert(HeaderName::from_static(CORRELATION_ID_HEADER), header_value);
-            }
-
-            response
-        }
-
-        // WASM path
-        #[cfg(target_arch = "wasm32")]
-        {
-            // Create a span for this request with trace context information
-            let span = tracing::info_span!(
-                "http_request",
-                correlation_id = %correlation_id,
-                method = %request.method(),
-                path = %request.uri().path(),
-                otel.name = "http_request",
-                otel.kind = "SERVER",
-                // Include trace and span IDs for OpenTelemetry
-                trace_id = %correlation_id.trace_id(),
-                span_id = %correlation_id.span_id(),
-                // Include the traceparent header for propagation
-                traceparent = %correlation_id.to_traceparent()
-            );
-
-            // Process request with the span attached
-            let mut response = next.run(request).instrument(span).await;
-
-            // Add both W3C and legacy headers to response
-            let headers = response.headers_mut();
-
-            // Always inject W3C headers
-            if let Err(e) = inject_trace_context(correlation_id.trace_context(), headers) {
-                tracing::warn!("Failed to inject trace context headers: {}", e);
-            }
-
-            // Also add legacy header for backward compatibility
-            if let Ok(header_value) = HeaderValue::from_str(&correlation_id.to_string()) {
-                headers.insert(HeaderName::from_static(CORRELATION_ID_HEADER), header_value);
-            }
-
-            response
-        }
-    }
-}
-
-/// Extension trait for extracting correlation ID from request
-pub trait CorrelationIdExt {
-    /// Get the correlation ID from request extensions
-    fn correlation_id(&self) -> Option<&CorrelationId>;
-}
-
-impl CorrelationIdExt for Request {
-    fn correlation_id(&self) -> Option<&CorrelationId> {
-        self.extensions().get::<CorrelationId>()
-    }
-}
diff --git a/crates/http/src/middleware/metrics.rs b/crates/http/src/middleware/metrics.rs
deleted file mode 100644
index 51abe70a..00000000
--- a/crates/http/src/middleware/metrics.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-//! HTTP metrics middleware for request tracking
-//!
-//! This middleware collects metrics about HTTP requests including:
-//! - Request count by method and status
-//! - Request duration histogram
-//! - Active request gauge
-
-use axum::{extract::Request, middleware::Next, response::IntoResponse};
-use gate_core::tracing::prelude::*;
-use std::time::Instant;
-
-/// Middleware to collect HTTP request metrics
-pub async fn metrics_middleware(request: Request, next: Next) -> impl IntoResponse {
-    let method = request.method().to_string();
-    let path = request.uri().path().to_string();
-    let start = Instant::now();
-
-    // Create a span for metrics tracking
-    let span = tracing::debug_span!(
-        "http_metrics",
-        method = %method,
-        path = %path
-    );
-
-    // Increment active requests gauge
-    gauge("http_requests_active").increment();
-
-    // Process the request with the span attached
-    let response = next.run(request).instrument(span).await;
-
-    // Decrement active requests gauge
-    gauge("http_requests_active").decrement();
-
-    // Record request metrics
-    let duration = start.elapsed();
-    let status = response.status().as_u16();
-    let status_class = format!("{}xx", status / 100);
-
-    // Log request completion
-    tracing::debug!(
-        status = status,
-        duration_ms = ?duration.as_millis(),
-        "Request completed"
-    );
-
-    // Increment request counter by method and status class
-    counter(&format!(
-        "http_requests_total_{}_{}",
-        method.to_lowercase(),
-        status_class
-    ))
-    .increment();
-
-    // Also track overall request count
-    counter("http_requests_total").increment();
-
-    // Record request duration by method
-    histogram(&format!(
-        "http_request_duration_seconds_{}",
-        method.to_lowercase()
-    ))
-    .observe(duration.as_secs_f64());
-
-    // Also record to overall histogram
-    histogram("http_request_duration_seconds").observe(duration.as_secs_f64());
-
-    response
-}
diff --git a/crates/http/src/middleware/mod.rs b/crates/http/src/middleware/mod.rs
deleted file mode 100644
index 630f0d1e..00000000
--- a/crates/http/src/middleware/mod.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//! Middleware components for HTTP request processing
-
-pub mod auth;
-pub mod correlation;
-pub mod metrics;
-pub mod trace;
-#[cfg(not(target_arch = "wasm32"))]
-pub mod webauthn;
-
-pub use auth::{AuthProvider, auth_middleware};
-pub use correlation::{
-    CORRELATION_ID_HEADER, CorrelationIdExt, correlation_id_middleware, extract_correlation_id,
-};
-pub use metrics::metrics_middleware;
-pub use trace::with_request_tracing;
-#[cfg(not(target_arch = "wasm32"))]
-pub use webauthn::{WebAuthnConfig, WebAuthnState};
diff --git a/crates/http/src/middleware/trace.rs b/crates/http/src/middleware/trace.rs
deleted file mode 100644
index bd8e0690..00000000
--- a/crates/http/src/middleware/trace.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-//! Request tracing layer factory.
-
-use crate::middleware::CORRELATION_ID_HEADER;
-use axum::{
-    Router,
-    http::{Request, Response},
-};
-use std::time::Duration;
-use tower_http::{classify::ServerErrorsFailureClass, trace::TraceLayer};
-use tracing::Span;
-
-/// Add a `TraceLayer` configured to log completion status and latency.
-/// - INFO for < 400, WARN for 4xx, ERROR for 5xx
-/// - Includes correlation id header if present
-pub fn with_request_tracing<State>(router: Router<State>) -> Router<State>
-where
-    State: Clone + Send + Sync + 'static,
-{
-    let layer = TraceLayer::new_for_http()
-        .make_span_with(|req: &Request<_>| {
-            let method = req.method();
-            let path = req.uri().path();
-            info_span!("http", %method, %path)
-        })
-        .on_response(|res: &Response<_>, latency: Duration, span: &Span| {
-            let status = res.status();
-            let cid = res
-                .headers()
-                .get(CORRELATION_ID_HEADER)
-                .and_then(|v| v.to_str().ok());
-            span.in_scope(|| {
-                if status.is_server_error() {
-                    if let Some(cid) = cid {
-                        error!(%status, elapsed_ms = latency.as_millis(), correlation_id = %cid, "request completed");
-                    } else {
-                        error!(%status, elapsed_ms = latency.as_millis(), "request completed");
-                    }
-                } else if status.is_client_error() {
-                    if let Some(cid) = cid {
-                        warn!(%status, elapsed_ms = latency.as_millis(), correlation_id = %cid, "request completed");
-                    } else {
-                        warn!(%status, elapsed_ms = latency.as_millis(), "request completed");
-                    }
-                } else if let Some(cid) = cid {
-                    info!(%status, elapsed_ms = latency.as_millis(), correlation_id = %cid, "request completed");
-                } else {
-                    info!(%status, elapsed_ms = latency.as_millis(), "request completed");
-                }
-            })
-        })
-        .on_failure(|error: ServerErrorsFailureClass, latency: Duration, span: &Span| {
-            span.in_scope(|| {
-                match error {
-                    ServerErrorsFailureClass::StatusCode(status) if status.is_client_error() => {
-                        warn!(%status, elapsed_ms = latency.as_millis(), "request failed");
-                    }
-                    ServerErrorsFailureClass::StatusCode(status) => {
-                        error!(%status, elapsed_ms = latency.as_millis(), "request failed");
-                    }
-                    other => {
-                        error!(failure = ?other, elapsed_ms = latency.as_millis(), "request failed");
-                    }
-                }
-            })
-        });
-
-    router.layer(layer)
-}
diff --git a/crates/http/src/middleware/webauthn.rs b/crates/http/src/middleware/webauthn.rs
deleted file mode 100644
index 81a84e5f..00000000
--- a/crates/http/src/middleware/webauthn.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-//! WebAuthn authentication middleware and types
-
-use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
-use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-use tokio::sync::RwLock;
-use webauthn_rs::{Webauthn, WebauthnBuilder};
-
-/// WebAuthn configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct WebAuthnConfig {
-    /// Relying Party ID (domain name)
-    pub rp_id: String,
-    /// Relying Party Name (display name)
-    pub rp_name: String,
-    /// Relying Party origin (https://example.com)
-    pub rp_origin: String,
-    /// Additional allowed origins
-    pub allowed_origins: Vec<String>,
-    /// Allow relay origins automatically
-    pub allow_tlsforward_origins: bool,
-    /// Allow subdomains of configured origins
-    pub allow_subdomains: bool,
-    /// Require user verification
-    pub require_user_verification: bool,
-    /// Session timeout in seconds
-    pub session_timeout_seconds: u64,
-}
-
-/// Session data for ongoing WebAuthn operations
-#[derive(Debug, Clone)]
-pub struct WebAuthnSession {
-    pub user_name: Option<String>,
-    pub registration_state: Option<webauthn_rs::prelude::PasskeyRegistration>,
-    pub authentication_state: Option<webauthn_rs::prelude::PasskeyAuthentication>,
-    pub created_at: DateTime<Utc>,
-}
-
-/// WebAuthn state manager
-pub struct WebAuthnState {
-    webauthn: Arc<RwLock<Webauthn>>,
-    sessions: Arc<RwLock<std::collections::HashMap<String, WebAuthnSession>>>,
-    config: Arc<RwLock<WebAuthnConfig>>,
-}
-
-impl WebAuthnState {
-    /// Create a new WebAuthn state manager
-    pub fn new(config: WebAuthnConfig) -> Result<Self, Box<dyn std::error::Error>> {
-        let origin_url = webauthn_rs::prelude::Url::parse(&config.rp_origin)?;
-        let mut builder = WebauthnBuilder::new(&config.rp_id, &origin_url)?;
-
-        // Set the RP name
-        builder = builder.rp_name(&config.rp_name);
-
-        // Add additional allowed origins
-        for origin_str in &config.allowed_origins {
-            if let Ok(origin) = webauthn_rs::prelude::Url::parse(origin_str) {
-                builder = builder.append_allowed_origin(&origin);
-            }
-        }
-
-        // Configure subdomain support
-        if config.allow_subdomains {
-            builder = builder.allow_subdomains(true);
-        }
-
-        let webauthn = Arc::new(RwLock::new(builder.build()?));
-
-        Ok(Self {
-            webauthn,
-            sessions: Arc::new(RwLock::new(std::collections::HashMap::new())),
-            config: Arc::new(RwLock::new(config)),
-        })
-    }
-
-    /// Generate a new session ID
-    pub fn generate_session_id() -> String {
-        let random_bytes: [u8; 32] = rand::random();
-        URL_SAFE_NO_PAD.encode(random_bytes)
-    }
-
-    /// Store a session
-    pub async fn store_session(&self, session_id: String, session: WebAuthnSession) {
-        let mut sessions = self.sessions.write().await;
-        sessions.insert(session_id, session);
-    }
-
-    /// Get a session
-    pub async fn get_session(&self, session_id: &str) -> Option<WebAuthnSession> {
-        let sessions = self.sessions.read().await;
-        sessions.get(session_id).cloned()
-    }
-
-    /// Remove a session
-    pub async fn remove_session(&self, session_id: &str) {
-        let mut sessions = self.sessions.write().await;
-        sessions.remove(session_id);
-    }
-
-    /// Clean up expired sessions
-    pub async fn cleanup_expired_sessions(&self) {
-        let mut sessions = self.sessions.write().await;
-        let now = Utc::now();
-        let config = self.config.read().await;
-        let timeout = chrono::Duration::seconds(config.session_timeout_seconds as i64);
-
-        sessions.retain(|_, session| now - session.created_at < timeout);
-    }
-
-    /// Get the WebAuthn instance
-    pub fn webauthn(&self) -> Arc<RwLock<Webauthn>> {
-        self.webauthn.clone()
-    }
-
-    /// Add a new allowed origin dynamically
-    pub async fn add_allowed_origin(
-        &self,
-        origin: String,
-    ) -> Result<(), Box<dyn std::error::Error>> {
-        let mut config = self.config.write().await;
-
-        // Check if origin already exists
-        if config.allowed_origins.contains(&origin) {
-            return Ok(());
-        }
-
-        // Add the new origin to config
-        config.allowed_origins.push(origin.clone());
-
-        // Rebuild WebAuthn instance with new origins
-        let origin_url = webauthn_rs::prelude::Url::parse(&config.rp_origin)?;
-        let mut builder = WebauthnBuilder::new(&config.rp_id, &origin_url)?;
-
-        // Set the RP name
-        builder = builder.rp_name(&config.rp_name);
-
-        // Add all allowed origins
-        for origin_str in &config.allowed_origins {
-            if let Ok(origin) = webauthn_rs::prelude::Url::parse(origin_str) {
-                builder = builder.append_allowed_origin(&origin);
-            }
-        }
-
-        // Configure subdomain support
-        if config.allow_subdomains {
-            builder = builder.allow_subdomains(true);
-        }
-
-        let new_webauthn = builder.build()?;
-        let mut webauthn = self.webauthn.write().await;
-        *webauthn = new_webauthn;
-
-        tracing::info!("Added allowed origin for WebAuthn: {}", origin);
-
-        Ok(())
-    }
-}
diff --git a/crates/http/src/routes/health.rs b/crates/http/src/routes/health.rs
deleted file mode 100644
index ffd7a476..00000000
--- a/crates/http/src/routes/health.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//! Health check handler
-
-use axum::{Router, response::Json, routing::get};
-use serde::{Deserialize, Serialize};
-
-/// Health check response
-#[derive(Debug, Serialize, Deserialize)]
-pub struct HealthResponse {
-    pub status: String,
-    pub version: String,
-    pub timestamp: chrono::DateTime<chrono::Utc>,
-}
-
-/// Health check endpoint
-pub async fn health_check() -> Json<HealthResponse> {
-    Json(HealthResponse {
-        status: "healthy".to_string(),
-        version: env!("CARGO_PKG_VERSION").to_string(),
-        timestamp: chrono::Utc::now(),
-    })
-}
-
-pub fn router<T>() -> Router<T>
-where
-    T: Send + Sync + Clone + 'static,
-{
-    Router::new().route("/health", get(health_check))
-}
diff --git a/crates/http/src/routes/inference.rs b/crates/http/src/routes/inference.rs
deleted file mode 100644
index 194cacc9..00000000
--- a/crates/http/src/routes/inference.rs
+++ /dev/null
@@ -1,246 +0,0 @@
-//! Inference API routes for LLM providers
-
-use crate::{
-    auth::extract_identity,
-    error::HttpError,
-    sinks::response_converter::{response_stream_to_axum, response_stream_to_json},
-    state::AppState,
-    types::*,
-};
-use http::header::HeaderName;
-const X_TRACE_ID: HeaderName = HeaderName::from_static("x-trace-id");
-use axum::{
-    Router,
-    extract::{Json, State},
-    http::HeaderMap,
-    response::Response,
-    routing::post,
-};
-use gate_core::router::{
-    service::route_and_execute_json_with_protocol, sink::RequestContext, types::Protocol,
-};
-use gate_core::tracing::prelude::*;
-
-/// Handle Anthropic messages requests
-#[instrument(
-    name = "anthropic_messages",
-    skip(app_state, headers),
-    fields(
-        model = %request.model,
-        request_id = tracing::field::Empty
-    )
-)]
-pub async fn messages_handler<T>(
-    State(app_state): State<AppState<T>>,
-    uri: axum::http::Uri,
-    headers: HeaderMap,
-    axum::Extension(correlation_id): axum::Extension<CorrelationId>,
-    Json(request): Json<AnthropicMessagesRequest>,
-) -> Result<Response, HttpError>
-where
-    T: Clone + Send + Sync + 'static,
-{
-    let router = app_state
-        .router
-        .ok_or_else(|| HttpError::InternalServerError("Router not configured".to_string()))?;
-
-    let ctx = RequestContext {
-        identity: extract_identity(&headers),
-        correlation_id,
-        headers: headers.clone(),
-        query: uri.query().map(|s| s.to_string()),
-        trace_id: headers
-            .get(X_TRACE_ID)
-            .and_then(|v| v.to_str().ok())
-            .map(String::from),
-        metadata: Default::default(),
-    };
-
-    let request_json = serde_json::to_value(&request)
-        .map_err(|e| HttpError::InternalServerError(format!("Failed to serialize request: {e}")))?;
-
-    let stream = route_and_execute_json_with_protocol(
-        router.as_ref(),
-        &ctx,
-        Protocol::Anthropic,
-        request_json,
-    )
-    .await?;
-
-    if request.stream {
-        response_stream_to_axum(stream).await
-    } else {
-        response_stream_to_json(stream).await
-    }
-}
-
-/// Handle OpenAI chat completions requests
-#[instrument(
-    name = "openai_chat_completions",
-    skip(app_state, headers),
-    fields(
-        model = %request.model,
-        stream = %request.stream
-    )
-)]
-pub async fn chat_completions_handler<T>(
-    State(app_state): State<AppState<T>>,
-    uri: axum::http::Uri,
-    headers: HeaderMap,
-    axum::Extension(correlation_id): axum::Extension<CorrelationId>,
-    Json(request): Json<OpenAIChatCompletionRequest>,
-) -> Result<Response, HttpError>
-where
-    T: Clone + Send + Sync + 'static,
-{
-    let router = app_state
-        .router
-        .ok_or_else(|| HttpError::InternalServerError("Router not configured".to_string()))?;
-
-    let ctx = RequestContext {
-        identity: extract_identity(&headers),
-        correlation_id,
-        headers: headers.clone(),
-        query: uri.query().map(|s| s.to_string()),
-        trace_id: headers
-            .get(X_TRACE_ID)
-            .and_then(|v| v.to_str().ok())
-            .map(String::from),
-        metadata: Default::default(),
-    };
-
-    let request_json = serde_json::to_value(&request)
-        .map_err(|e| HttpError::InternalServerError(format!("Failed to serialize request: {e}")))?;
-
-    let stream = route_and_execute_json_with_protocol(
-        router.as_ref(),
-        &ctx,
-        Protocol::OpenAIChat,
-        request_json,
-    )
-    .await?;
-
-    if request.stream {
-        response_stream_to_axum(stream).await
-    } else {
-        response_stream_to_json(stream).await
-    }
-}
-
-/// Handle OpenAI responses requests
-#[instrument(
-    name = "openai_responses",
-    skip(app_state, headers),
-    fields(
-        model = %request.model,
-        stream = %request.stream
-    )
-)]
-pub async fn responses_handler<T>(
-    State(app_state): State<AppState<T>>,
-    uri: axum::http::Uri,
-    headers: HeaderMap,
-    axum::Extension(correlation_id): axum::Extension<CorrelationId>,
-    Json(request): Json<OpenAICompletionRequest>,
-) -> Result<Response, HttpError>
-where
-    T: Clone + Send + Sync + 'static,
-{
-    let router = app_state
-        .router
-        .ok_or_else(|| HttpError::InternalServerError("Router not configured".to_string()))?;
-
-    let ctx = RequestContext {
-        identity: extract_identity(&headers),
-        correlation_id,
-        headers: headers.clone(),
-        query: uri.query().map(|s| s.to_string()),
-        trace_id: headers
-            .get(X_TRACE_ID)
-            .and_then(|v| v.to_str().ok())
-            .map(String::from),
-        metadata: Default::default(),
-    };
-
-    let request_json = serde_json::to_value(&request)
-        .map_err(|e| HttpError::InternalServerError(format!("Failed to serialize request: {e}")))?;
-
-    let stream = route_and_execute_json_with_protocol(
-        router.as_ref(),
-        &ctx,
-        Protocol::OpenAIResponses,
-        request_json,
-    )
-    .await?;
-
-    if request.stream {
-        response_stream_to_axum(stream).await
-    } else {
-        response_stream_to_json(stream).await
-    }
-}
-
-/// Create inference router
-pub fn router<T>() -> Router<AppState<T>>
-where
-    T: Send + Sync + Clone + 'static,
-{
-    Router::new()
-        .route("/v1/chat/completions", post(chat_completions_handler))
-        .route("/v1/responses", post(responses_handler))
-        .route("/v1/completions", post(completions_handler))
-        .route("/v1/messages", post(messages_handler))
-}
-
-/// Handle OpenAI completions (legacy) requests
-#[instrument(
-    name = "openai_completions",
-    skip(app_state, headers),
-    fields(
-        model = %request.model,
-        stream = %request.stream
-    )
-)]
-pub async fn completions_handler<T>(
-    State(app_state): State<AppState<T>>,
-    uri: axum::http::Uri,
-    headers: HeaderMap,
-    axum::Extension(correlation_id): axum::Extension<CorrelationId>,
-    Json(request): Json<OpenAICompletionRequest>,
-) -> Result<Response, HttpError>
-where
-    T: Clone + Send + Sync + 'static,
-{
-    let router = app_state
-        .router
-        .ok_or_else(|| HttpError::InternalServerError("Router not configured".to_string()))?;
-
-    let ctx = RequestContext {
-        identity: extract_identity(&headers),
-        correlation_id,
-        headers: headers.clone(),
-        query: uri.query().map(|s| s.to_string()),
-        trace_id: headers
-            .get(X_TRACE_ID)
-            .and_then(|v| v.to_str().ok())
-            .map(String::from),
-        metadata: Default::default(),
-    };
-
-    let request_json = serde_json::to_value(&request)
-        .map_err(|e| HttpError::InternalServerError(format!("Failed to serialize request: {e}")))?;
-
-    let stream = route_and_execute_json_with_protocol(
-        router.as_ref(),
-        &ctx,
-        Protocol::OpenAICompletions,
-        request_json,
-    )
-    .await?;
-
-    if request.stream {
-        response_stream_to_axum(stream).await
-    } else {
-        response_stream_to_json(stream).await
-    }
-}
diff --git a/crates/http/src/routes/mod.rs b/crates/http/src/routes/mod.rs
deleted file mode 100644
index f9babe21..00000000
--- a/crates/http/src/routes/mod.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//! API route definitions
-
-pub mod health;
-pub mod inference;
-pub mod models;
-pub mod observability;
-
-use axum::Router;
-
-pub fn router<T>() -> Router<crate::AppState<T>>
-where
-    T: Send + Sync + Clone + 'static,
-{
-    Router::new()
-        .merge(health::router())
-        .merge(inference::router())
-        .merge(models::router())
-        .merge(observability::router())
-}
diff --git a/crates/http/src/routes/models/mod.rs b/crates/http/src/routes/models/mod.rs
deleted file mode 100644
index 2cf38685..00000000
--- a/crates/http/src/routes/models/mod.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-//! Models API routes
-
-use crate::{
-    error::HttpError,
-    state::AppState,
-    types::{ModelInfo, ModelsListResponse},
-};
-use axum::{
-    Router,
-    extract::State,
-    response::{IntoResponse, Json, Response},
-    routing::get,
-};
-use gate_core::router::prelude::Sink;
-use tracing::{info, instrument};
-
-/// Handle models list requests
-#[instrument(
-    name = "list_models",
-    skip(app_state),
-    fields(
-        model_count = tracing::field::Empty
-    )
-)]
-pub async fn models_handler<T>(State(app_state): State<AppState<T>>) -> Result<Response, HttpError>
-where
-    T: Clone + Send + Sync + 'static,
-{
-    info!("Received models list request");
-
-    let mut models = Vec::new();
-
-    // Get models from router if available
-    if let Some(router) = &app_state.router {
-        let desc = router.describe().await;
-        match desc.models {
-            gate_core::router::types::ModelList::Static(list) => {
-                for id in list {
-                    models.push(ModelInfo {
-                        id,
-                        object: "model".to_string(),
-                        owned_by: "system".to_string(),
-                        created: chrono::Utc::now().timestamp(),
-                        context_length: desc.capabilities.max_context_length,
-                    });
-                }
-            }
-            gate_core::router::types::ModelList::Dynamic => {
-                // Dynamic models are resolved at runtime
-                info!("Router has dynamic model list");
-            }
-            gate_core::router::types::ModelList::Infinite => {
-                // Router accepts any model name
-                info!("Router accepts any model");
-            }
-        }
-    }
-
-    tracing::Span::current().record("model_count", models.len());
-
-    let response = ModelsListResponse {
-        object: "list".to_string(),
-        data: models,
-    };
-
-    Ok(Json(response).into_response())
-}
-
-/// Create models router
-pub fn router<T>() -> Router<AppState<T>>
-where
-    T: Send + Sync + Clone + 'static,
-{
-    Router::new().route("/v1/models", get(models_handler))
-}
diff --git a/crates/http/src/routes/observability.rs b/crates/http/src/routes/observability.rs
deleted file mode 100644
index 0d1f544e..00000000
--- a/crates/http/src/routes/observability.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-//! Observability endpoints for metrics and health checks
-
-use axum::{
-    Router,
-    http::StatusCode,
-    response::{IntoResponse, Response},
-    routing::get,
-};
-#[cfg(all(feature = "otlp", not(target_arch = "wasm32")))]
-use gate_core::tracing::prometheus::prometheus_format;
-
-/// Prometheus metrics endpoint
-#[cfg(feature = "otlp")]
-pub async fn metrics_handler() -> Response {
-    let metrics = prometheus_format();
-
-    (
-        StatusCode::OK,
-        [(
-            axum::http::header::CONTENT_TYPE,
-            "text/plain; version=0.0.4",
-        )],
-        metrics,
-    )
-        .into_response()
-}
-
-/// Prometheus metrics endpoint (stub when otlp is disabled)
-#[cfg(not(feature = "otlp"))]
-pub async fn metrics_handler() -> Response {
-    (
-        StatusCode::OK,
-        [(
-            axum::http::header::CONTENT_TYPE,
-            "text/plain; version=0.0.4",
-        )],
-        "# Metrics collection disabled (compile with 'otlp' feature)\n",
-    )
-        .into_response()
-}
-
-/// Create observability router
-pub fn router<T>() -> Router<T>
-where
-    T: Clone + Send + Sync + 'static,
-{
-    Router::new().route("/metrics", get(metrics_handler))
-}
diff --git a/crates/http/src/server.rs b/crates/http/src/server.rs
deleted file mode 100644
index cad92ecc..00000000
--- a/crates/http/src/server.rs
+++ /dev/null
@@ -1,81 +0,0 @@
-//! HTTP server utilities for handling streams from various sources
-
-use axum::Router;
-use axum::extract::Request;
-use hyper::body::Incoming;
-use hyper_util::rt::{TokioExecutor, TokioIo};
-use hyper_util::server;
-use tokio::io::{AsyncRead, AsyncWrite};
-use tower::Service;
-
-/// HTTP server that can handle streams from various sources (TCP, P2P, etc.)
-#[derive(Clone, Debug)]
-pub struct HttpServer {
-    router: Router<()>,
-}
-
-impl HttpServer {
-    /// Create a new HTTP server with the given router
-    pub fn new(router: Router<()>) -> Self {
-        Self { router }
-    }
-
-    /// Handle a stream
-    #[tracing::instrument(name = "http.handle_stream", skip_all)]
-    pub async fn handle_stream<S>(&self, stream: S) -> anyhow::Result<()>
-    where
-        S: AsyncRead + AsyncWrite + Send + Unpin + 'static,
-    {
-        debug!("Handling stream");
-
-        // Clone router
-        let router = self.router.clone();
-
-        // Wrap the stream for hyper compatibility
-        let io = TokioIo::new(stream);
-
-        // Router<()> implements Service<Request<Incoming>> directly
-        let hyper_service = hyper::service::service_fn(move |request: Request<Incoming>| {
-            router.clone().call(request)
-        });
-
-        // Serve the connection using hyper's low-level API
-        // This supports both HTTP/1 and HTTP/2 with upgrades (needed for WebSockets)
-        let result = server::conn::auto::Builder::new(TokioExecutor::new())
-            .serve_connection_with_upgrades(io, hyper_service)
-            .await;
-
-        match result {
-            Ok(()) => {
-                debug!("Stream handling completed successfully");
-                Ok(())
-            }
-            Err(e) => {
-                error!("HTTP connection error: {}", e);
-                Err(anyhow::anyhow!("HTTP connection error: {}", e))
-            }
-        }
-    }
-
-    /// Handle a P2P stream
-    #[tracing::instrument(
-        name = "http.handle_p2p_stream",
-        skip_all,
-        fields(
-            p2p.node_id = %node_id,
-            p2p.relay_domain = _relay_domain.as_deref().unwrap_or("direct")
-        )
-    )]
-    pub async fn handle_p2p_stream<S>(
-        &self,
-        stream: S,
-        node_id: impl std::fmt::Display,
-        _relay_domain: Option<String>,
-    ) -> anyhow::Result<()>
-    where
-        S: AsyncRead + AsyncWrite + Send + Unpin + 'static,
-    {
-        info!("Handling P2P stream from node: {}", node_id);
-        self.handle_stream(stream).await
-    }
-}
diff --git a/crates/http/src/services/identity.rs b/crates/http/src/services/identity.rs
deleted file mode 100644
index 4ef188e4..00000000
--- a/crates/http/src/services/identity.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-use crate::error::HttpError;
-use axum::extract::FromRequestParts;
-use axum::http::request::Parts;
-use gate_core::access::{IdentityContext, SubjectIdentity};
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::ops::Deref;
-
-/// Generic HTTP context that can be used by any deployment
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct HttpContext {
-    pub attributes: HashMap<String, String>,
-}
-
-impl HttpContext {
-    pub fn new() -> Self {
-        Self {
-            attributes: HashMap::new(),
-        }
-    }
-
-    pub fn with_attribute(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
-        self.attributes.insert(key.into(), value.into());
-        self
-    }
-}
-
-impl IdentityContext for HttpContext {
-    fn to_attributes(&self) -> HashMap<String, String> {
-        self.attributes.clone()
-    }
-
-    fn get(&self, key: &str) -> Option<&str> {
-        self.attributes.get(key).map(|s| s.as_str())
-    }
-}
-
-impl Default for HttpContext {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-/// HTTP identity wrapper that can implement FromRequestParts
-#[derive(Debug, Clone)]
-pub struct HttpIdentity(pub SubjectIdentity<HttpContext>);
-
-impl HttpIdentity {
-    pub fn new(id: String, source: String, context: HttpContext) -> Self {
-        Self(SubjectIdentity {
-            id,
-            source,
-            context,
-        })
-    }
-}
-
-impl Deref for HttpIdentity {
-    type Target = SubjectIdentity<HttpContext>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl<S> FromRequestParts<S> for HttpIdentity
-where
-    S: Send + Sync,
-{
-    type Rejection = HttpError;
-
-    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
-        parts
-            .extensions
-            .get::<HttpIdentity>()
-            .cloned()
-            .ok_or_else(|| HttpError::AuthenticationFailed("User not authenticated".to_string()))
-    }
-}
diff --git a/crates/http/src/services/jwt.rs b/crates/http/src/services/jwt.rs
deleted file mode 100644
index 696fa8ec..00000000
--- a/crates/http/src/services/jwt.rs
+++ /dev/null
@@ -1,182 +0,0 @@
-//! JWT service for token management
-
-use crate::error::HttpError;
-use chrono::{Duration, Utc};
-use jsonwebtoken::{Algorithm, DecodingKey, EncodingKey, Header, Validation, decode, encode};
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-
-/// JWT Claims structure
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Claims {
-    /// Subject (user ID)
-    pub sub: String,
-    /// User's display name
-    pub name: Option<String>,
-    /// Expiration time (as UTC timestamp)
-    pub exp: i64,
-    /// Issued at (as UTC timestamp)
-    pub iat: i64,
-    /// Issuer
-    pub iss: String,
-}
-
-/// JWT service configuration
-#[derive(Clone, Debug)]
-pub struct JwtConfig {
-    /// Secret key for signing tokens
-    pub secret: String,
-    /// Token expiration duration
-    pub expiration: Duration,
-    /// Token issuer
-    pub issuer: String,
-}
-
-impl JwtConfig {
-    /// Default configuration with 24 hours expiration
-    pub fn new(secret: String, expiration_hours: i64, issuer: String) -> Self {
-        Self {
-            secret,
-            expiration: Duration::hours(expiration_hours),
-            issuer,
-        }
-    }
-}
-
-/// JWT service for token operations
-pub struct JwtService {
-    config: Arc<JwtConfig>,
-    encoding_key: EncodingKey,
-    decoding_key: DecodingKey,
-}
-
-impl JwtService {
-    /// Create a new JWT service
-    pub fn new(config: JwtConfig) -> Self {
-        let encoding_key = EncodingKey::from_secret(config.secret.as_bytes());
-        let decoding_key = DecodingKey::from_secret(config.secret.as_bytes());
-
-        Self {
-            config: Arc::new(config),
-            encoding_key,
-            decoding_key,
-        }
-    }
-
-    /// Generate a JWT token for a user
-    pub fn generate_token(&self, user_id: &str, name: Option<&str>) -> Result<String, HttpError> {
-        let now = Utc::now();
-        let expiration = now + self.config.expiration;
-
-        let claims = Claims {
-            sub: user_id.to_string(),
-            name: name.map(|s| s.to_string()),
-            exp: expiration.timestamp(),
-            iat: now.timestamp(),
-            iss: self.config.issuer.clone(),
-        };
-
-        let header = Header::new(Algorithm::HS256);
-
-        encode(&header, &claims, &self.encoding_key)
-            .map_err(|e| HttpError::InternalServerError(format!("Failed to generate token: {e}")))
-    }
-
-    /// Validate a JWT token and extract claims
-    pub fn validate_token(&self, token: &str) -> Result<Claims, HttpError> {
-        let mut validation = Validation::new(Algorithm::HS256);
-        validation.set_issuer(std::slice::from_ref(&self.config.issuer));
-        decode::<Claims>(token, &self.decoding_key, &validation)
-            .map(|token_data| token_data.claims)
-            .map_err(|e| match e.kind() {
-                jsonwebtoken::errors::ErrorKind::ExpiredSignature => {
-                    HttpError::AuthenticationFailed("Token has expired".to_string())
-                }
-                jsonwebtoken::errors::ErrorKind::InvalidToken => {
-                    HttpError::AuthenticationFailed("Invalid token".to_string())
-                }
-                _ => HttpError::AuthenticationFailed(format!("Token validation failed: {e}")),
-            })
-    }
-
-    /// Extract token from Authorization header
-    pub fn extract_bearer_token<'a>(&self, auth_header: &'a str) -> Result<&'a str, HttpError> {
-        if let Some(token) = auth_header.strip_prefix("Bearer ") {
-            Ok(token)
-        } else {
-            Err(HttpError::AuthenticationFailed(
-                "Invalid authorization header format".to_string(),
-            ))
-        }
-    }
-
-    /// Get the token expiration duration
-    pub fn expiration(&self) -> Duration {
-        self.config.expiration
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_token_generation_and_validation() {
-        let config = JwtConfig::new("test-secret".to_string(), 24, "test-issuer".to_string());
-        let service = JwtService::new(config);
-        let user_id = "test-user-123";
-        let name = Some("Test User");
-
-        // Generate token
-        let token = service.generate_token(user_id, name).unwrap();
-        assert!(!token.is_empty());
-
-        // Validate token
-        let claims = service.validate_token(&token).unwrap();
-        assert_eq!(claims.sub, user_id);
-        assert_eq!(claims.name.as_deref(), name);
-    }
-
-    #[test]
-    fn test_expired_token() {
-        let config = JwtConfig::new("test-secret".to_string(), 24, "test-issuer".to_string());
-        let service = JwtService::new(config);
-
-        // Create a token with expired timestamp directly
-        let now = Utc::now();
-        let expired_time = now - Duration::seconds(3600); // 1 hour ago
-
-        let claims = Claims {
-            sub: "user".to_string(),
-            name: None,
-            exp: expired_time.timestamp(),
-            iat: expired_time.timestamp(),
-            iss: service.config.issuer.clone(),
-        };
-
-        let header = Header::new(Algorithm::HS256);
-        let token = encode(&header, &claims, &service.encoding_key).unwrap();
-
-        let result = service.validate_token(&token);
-        assert!(result.is_err());
-        if let Err(HttpError::AuthenticationFailed(msg)) = result {
-            assert!(msg.to_lowercase().contains("expired"));
-        } else {
-            panic!("Expected authentication failed error");
-        }
-    }
-
-    #[test]
-    fn test_extract_bearer_token() {
-        let config = JwtConfig::new("test-secret".to_string(), 24, "test-issuer".to_string());
-        let service = JwtService::new(config);
-
-        assert_eq!(
-            service.extract_bearer_token("Bearer abc123").unwrap(),
-            "abc123"
-        );
-
-        assert!(service.extract_bearer_token("Basic abc123").is_err());
-        assert!(service.extract_bearer_token("abc123").is_err());
-    }
-}
diff --git a/crates/http/src/services/mod.rs b/crates/http/src/services/mod.rs
deleted file mode 100644
index 280b8e08..00000000
--- a/crates/http/src/services/mod.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! Service layer for business logic
-
-pub mod identity;
-
-#[cfg(not(target_arch = "wasm32"))]
-pub mod jwt;
-
-pub use identity::{HttpContext, HttpIdentity};
-
-#[cfg(not(target_arch = "wasm32"))]
-pub use jwt::{Claims, JwtConfig, JwtService};
diff --git a/crates/http/src/sinks/anthropic.rs b/crates/http/src/sinks/anthropic.rs
deleted file mode 100644
index ff381400..00000000
--- a/crates/http/src/sinks/anthropic.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-//! Anthropic-specific sink factory
-
-use super::http_sink::{HttpSink, HttpSinkConfig, Provider};
-use crate::sinks::DEFAULT_SINK_TIMEOUT_SECS;
-use chrono::{DateTime, Utc};
-use gate_core::Result;
-use gate_core::router::types::{CostStructure, Protocol, SinkCapabilities};
-use http::header::{AUTHORIZATION, USER_AGENT};
-use http::{HeaderName, HeaderValue};
-use rust_decimal::Decimal;
-use serde::Deserialize;
-use std::str::FromStr;
-use std::time::Duration;
-use url::Url;
-
-pub(crate) const ANTHROPIC_VERSION: HeaderName = HeaderName::from_static("anthropic-version");
-pub(crate) const ANTHROPIC_VERSION_VALUE: HeaderValue = HeaderValue::from_static("2023-06-01");
-
-pub(crate) const ANTHROPIC_BETA: HeaderName = HeaderName::from_static("anthropic-beta");
-pub(crate) const ANTHROPIC_BETA_OAUTH: HeaderValue = HeaderValue::from_static("oauth-2025-04-20");
-
-pub(crate) const X_APP: HeaderName = HeaderName::from_static("x-app");
-pub(crate) const X_APP_VALUE: HeaderValue = HeaderValue::from_static("cli");
-
-pub(crate) const X_API_KEY: HeaderName = HeaderName::from_static("x-api-key");
-
-pub(crate) const CLAUDE_CODE_USER_AGENT: HeaderValue =
-    HeaderValue::from_static("claude-cli/1.0.102 (external, cli)");
-
-/// Configuration for Anthropic provider
-#[derive(Debug, Clone)]
-pub struct AnthropicConfig {
-    /// API key for Anthropic; if None, sink will operate in fallback mode and
-    /// accept client-supplied keys via request headers.
-    pub api_key: Option<String>,
-    pub base_url: Option<String>,
-    pub timeout_seconds: Option<u64>,
-    /// Optional sink ID to use in descriptions/registry keys
-    pub sink_id: Option<String>,
-}
-
-/// Create an Anthropic sink
-pub async fn create_sink(config: AnthropicConfig) -> Result<HttpSink> {
-    let base_url = config
-        .base_url
-        .unwrap_or_else(|| "https://api.anthropic.com".to_string());
-
-    // If we have an API key, fetch available models; otherwise leave dynamic.
-    let models = if let Some(ref key) = config.api_key {
-        fetch_models(&base_url, key).await?
-    } else {
-        Vec::new()
-    };
-
-    let timeout = Duration::from_secs(config.timeout_seconds.unwrap_or(DEFAULT_SINK_TIMEOUT_SECS));
-    let sink_config = HttpSinkConfig {
-        id: config
-            .sink_id
-            .clone()
-            .unwrap_or_else(|| "provider://anthropic".to_string()),
-        provider: Provider::Anthropic,
-        base_url,
-        api_key: config.api_key,
-        models,
-        timeout,
-        max_retries: 3,
-        accepted_protocols: vec![Protocol::Anthropic],
-        capabilities: SinkCapabilities {
-            supports_streaming: true,
-            supports_batching: false,
-            supports_tools: true,
-            max_context_length: Some(200000),
-            modalities: vec!["text".to_string(), "image".to_string()],
-        },
-        cost_structure: Some(CostStructure {
-            input_cost_per_token: Decimal::from_str("0.000015").unwrap(), // $15 per 1M tokens
-            output_cost_per_token: Decimal::from_str("0.000075").unwrap(), // $75 per 1M tokens
-            cached_input_cost_per_token: Some(Decimal::from_str("0.0000075").unwrap()), // 50% discount
-            currency: "USD".to_string(),
-        }),
-    };
-
-    HttpSink::new(sink_config)
-}
-
-/// Create a fallback Anthropic sink with no API key and default base URL.
-/// This sink will accept client-supplied API keys via headers and capture
-/// them after a successful response.
-pub async fn create_fallback_sink() -> Result<HttpSink> {
-    let config = AnthropicConfig {
-        api_key: None,
-        base_url: None,
-        timeout_seconds: Some(DEFAULT_SINK_TIMEOUT_SECS),
-        sink_id: Some("provider://anthropic/fallback".to_string()),
-    };
-    create_sink(config).await
-}
-
-#[derive(Deserialize)]
-struct AnthropicModelsResponse {
-    data: Vec<AnthropicModelItem>,
-}
-
-#[derive(Deserialize)]
-struct AnthropicModelItem {
-    id: String,
-    _display_name: String,
-    _created_at: DateTime<Utc>,
-}
-
-/// Fetch list of models from Anthropic
-pub async fn fetch_models(base_url: &str, api_key: &str) -> Result<Vec<String>> {
-    // Build URL safely: base_url + /v1/models
-    let mut url = Url::parse(base_url)
-        .map_err(|e| gate_core::Error::Internal(format!("Invalid base_url: {e}")))?;
-    {
-        let mut segs = url
-            .path_segments_mut()
-            .map_err(|_| gate_core::Error::Internal("Invalid base_url path".into()))?;
-        segs.pop_if_empty();
-        segs.extend(["v1", "models"]);
-    }
-    let client = reqwest::Client::builder()
-        .timeout(Duration::from_secs(5))
-        .build()
-        .map_err(|e| gate_core::Error::Internal(format!("Failed to build HTTP client: {e}")))?;
-
-    let resp = client
-        .get(url)
-        .header(AUTHORIZATION, format!("Bearer {api_key}"))
-        .header(ANTHROPIC_BETA, ANTHROPIC_BETA_OAUTH)
-        .header(ANTHROPIC_VERSION, ANTHROPIC_VERSION_VALUE)
-        .header(USER_AGENT, CLAUDE_CODE_USER_AGENT)
-        .header(X_APP, X_APP_VALUE)
-        .send()
-        .await
-        .map_err(|e| {
-            gate_core::Error::ServiceUnavailable(format!("Anthropic models request failed: {e}"))
-        })?
-        .error_for_status()
-        .map_err(|e| {
-            gate_core::Error::ServiceUnavailable(format!("Anthropic models request error: {e}"))
-        })?;
-
-    let payload: AnthropicModelsResponse = resp.json().await.map_err(|e| {
-        gate_core::Error::Internal(format!("Failed to parse Anthropic models: {e}"))
-    })?;
-
-    Ok(payload.data.into_iter().map(|m| m.id).collect())
-}
diff --git a/crates/http/src/sinks/http_sink.rs b/crates/http/src/sinks/http_sink.rs
deleted file mode 100644
index 905ff317..00000000
--- a/crates/http/src/sinks/http_sink.rs
+++ /dev/null
@@ -1,627 +0,0 @@
-//! Generic HTTP-based sink for external LLM providers
-
-use crate::sinks::anthropic::{
-    ANTHROPIC_BETA, ANTHROPIC_BETA_OAUTH, ANTHROPIC_VERSION, ANTHROPIC_VERSION_VALUE,
-    CLAUDE_CODE_USER_AGENT, X_API_KEY, X_APP, X_APP_VALUE,
-};
-
-use super::sse_parser::parse_sse;
-use async_trait::async_trait;
-use futures::StreamExt;
-use gate_core::router::sink::{RequestContext, ResponseStream, Sink, SinkDescription};
-use gate_core::router::types::{
-    CostStructure, ModelList, Protocol, RequestStream, ResponseChunk, SinkCapabilities, SinkHealth,
-    StopReason,
-};
-use gate_core::{Error, Result};
-use http::header::{AUTHORIZATION, USER_AGENT};
-use http::{HeaderName, HeaderValue, StatusCode};
-use reqwest::Client;
-use serde::{Deserialize, Serialize};
-use serde_json::Value as JsonValue;
-use std::sync::Arc;
-use std::time::Duration;
-use tokio::sync::RwLock;
-use url::{Url, form_urlencoded};
-
-/// Provider type for HTTP sinks
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum Provider {
-    Anthropic,
-    OpenAI,
-    OpenAICodex,
-    Custom,
-}
-
-impl std::fmt::Display for Provider {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Provider::Anthropic => write!(f, "anthropic"),
-            Provider::OpenAI => write!(f, "openai"),
-            Provider::OpenAICodex => write!(f, "openai-codex"),
-            Provider::Custom => write!(f, "custom"),
-        }
-    }
-}
-
-/// Configuration for an HTTP sink
-#[derive(Debug, Clone)]
-pub struct HttpSinkConfig {
-    pub id: String,
-    pub provider: Provider,
-    pub base_url: String,
-    pub api_key: Option<String>,
-    pub models: Vec<String>,
-    pub timeout: Duration,
-    pub max_retries: u32,
-    pub accepted_protocols: Vec<Protocol>,
-    pub capabilities: SinkCapabilities,
-    pub cost_structure: Option<CostStructure>,
-}
-
-/// HTTP-based sink for external LLM providers
-pub struct HttpSink {
-    config: HttpSinkConfig,
-    client: Client,
-    health: Arc<RwLock<SinkHealth>>,
-}
-
-impl HttpSink {
-    /// Create a new HTTP sink
-    pub fn new(config: HttpSinkConfig) -> Result<Self> {
-        let client = Client::builder()
-            .timeout(config.timeout)
-            .build()
-            .map_err(|e| Error::Internal(format!("Failed to create HTTP client: {e}")))?;
-
-        let health = Arc::new(RwLock::new(SinkHealth {
-            healthy: true,
-            latency_ms: None,
-            error_rate: 0.0,
-            last_error: None,
-            last_check: chrono::Utc::now(),
-        }));
-
-        Ok(Self {
-            config,
-            client,
-            health,
-        })
-    }
-
-    /// Get the appropriate authorization header for the provider
-    fn auth_header(&self) -> Option<(HeaderName, HeaderValue)> {
-        self.config
-            .api_key
-            .as_ref()
-            .and_then(|key| match self.config.provider {
-                Provider::Anthropic => {
-                    if key.starts_with("sk-ant-oat01-") {
-                        HeaderValue::from_str(&format!("Bearer {key}"))
-                            .ok()
-                            .map(|v| (AUTHORIZATION, v))
-                    } else {
-                        HeaderValue::from_str(key).ok().map(|v| (X_API_KEY, v))
-                    }
-                }
-                Provider::OpenAI | Provider::OpenAICodex | Provider::Custom => {
-                    HeaderValue::from_str(&format!("Bearer {key}"))
-                        .ok()
-                        .map(|v| (AUTHORIZATION, v))
-                }
-            })
-    }
-
-    /// Determine auth header from a client-supplied key (Anthropic and OpenAI)
-    fn inferred_auth_from_client_headers(
-        &self,
-        ctx: &RequestContext,
-    ) -> Option<(HeaderName, HeaderValue)> {
-        match self.config.provider {
-            Provider::Anthropic => {
-                // Prefer x-api-key when provided
-                if let Some(val) = ctx.headers.get(HeaderName::from_static("x-api-key"))
-                    && let Ok(key) = val.to_str()
-                    && !key.is_empty()
-                    && let Ok(hv) = HeaderValue::from_str(key)
-                {
-                    return Some((X_API_KEY, hv));
-                }
-                // Fallback to Authorization: Bearer sk-ant-...
-                if let Some(val) = ctx.headers.get(AUTHORIZATION)
-                    && let Ok(auth) = val.to_str()
-                    && auth.starts_with("Bearer sk-ant-")
-                    && let Ok(hv) = HeaderValue::from_str(auth)
-                {
-                    return Some((AUTHORIZATION, hv));
-                }
-                None
-            }
-            Provider::OpenAI | Provider::OpenAICodex | Provider::Custom => {
-                // OpenAI: Authorization: Bearer <token> (accept API keys or OAuth tokens)
-                if let Some(val) = ctx.headers.get(AUTHORIZATION)
-                    && let Ok(auth) = val.to_str()
-                    && auth.starts_with("Bearer ")
-                    && let Ok(hv) = HeaderValue::from_str(auth)
-                {
-                    return Some((AUTHORIZATION, hv));
-                }
-                // Some clients may pass x-api-key instead; convert to Authorization
-                if let Some(val) = ctx.headers.get(HeaderName::from_static("x-api-key"))
-                    && let Ok(key) = val.to_str()
-                    && !key.is_empty()
-                    && let Ok(hv) = HeaderValue::from_str(&format!("Bearer {key}"))
-                {
-                    return Some((AUTHORIZATION, hv));
-                }
-                None
-            }
-        }
-    }
-
-    /// Get provider-specific headers
-    fn provider_headers(&self) -> Vec<(HeaderName, HeaderValue)> {
-        match self.config.provider {
-            Provider::Anthropic => vec![
-                (ANTHROPIC_BETA, ANTHROPIC_BETA_OAUTH),
-                (ANTHROPIC_VERSION, ANTHROPIC_VERSION_VALUE),
-                (USER_AGENT, CLAUDE_CODE_USER_AGENT),
-                (X_APP, X_APP_VALUE),
-            ],
-            _ => vec![],
-        }
-    }
-
-    /// Get the endpoint for the given protocol
-    fn endpoint_for_protocol(&self, protocol: Protocol) -> Result<&'static str> {
-        match (protocol, &self.config.provider) {
-            (Protocol::OpenAIChat, Provider::OpenAI) => Ok("/v1/chat/completions"),
-            (Protocol::OpenAIChat, Provider::Anthropic) => Ok("/v1/messages"), // Anthropic uses messages
-            (Protocol::Anthropic, Provider::Anthropic) => Ok("/v1/messages"),
-            (Protocol::OpenAIMessages, Provider::OpenAI) => Ok("/v1/messages"),
-            (Protocol::OpenAICompletions, Provider::OpenAI) => Ok("/v1/completions"),
-            (Protocol::OpenAIResponses, Provider::OpenAI) => Ok("/v1/responses"),
-            (Protocol::OpenAIResponses, Provider::OpenAICodex) => Ok("/responses"),
-            _ => Err(Error::InvalidRoutingConfig(format!(
-                "Provider {} doesn't support protocol {:?}",
-                self.config.provider, protocol
-            ))),
-        }
-    }
-
-    /// Build the upstream URL from base_url, endpoint, and forwarded query
-    fn build_url(&self, ctx: &RequestContext, protocol: Protocol) -> Result<Url> {
-        let endpoint = self.endpoint_for_protocol(protocol)?;
-        let mut url = Url::parse(&self.config.base_url).map_err(|e| {
-            Error::Internal(format!(
-                "Invalid base_url for {}: {}",
-                self.config.provider, e
-            ))
-        })?;
-        url = url
-            .join(endpoint.trim_start_matches('/'))
-            .map_err(|e| Error::Internal(format!("Failed to join endpoint: {e}")))?;
-        if let Some(q) = &ctx.query {
-            let mut qp = url.query_pairs_mut();
-            qp.clear()
-                .extend_pairs(form_urlencoded::parse(q.as_bytes()));
-        }
-        Ok(url)
-    }
-
-    /// Execute a streaming request
-    async fn execute_streaming(
-        &self,
-        ctx: &RequestContext,
-        mut request_stream: RequestStream,
-    ) -> Result<ResponseStream> {
-        let request = self.get_first_request(&mut request_stream).await?;
-        let protocol = request_stream.protocol();
-        let url = self.build_url(ctx, protocol)?;
-
-        let req = self.prepare_http_request(url, &request, ctx);
-        let response = self.send_http_request(req).await?;
-        let response = self.validate_response_status(response).await?;
-        self.process_response(response, protocol).await
-    }
-
-    /// Get and validate the first request from the stream
-    async fn get_first_request(&self, stream: &mut RequestStream) -> Result<JsonValue> {
-        stream
-            .next()
-            .await
-            .ok_or_else(|| Error::InvalidRequest("Empty request stream".to_string()))?
-    }
-
-    /// Prepare the HTTP request with all necessary headers
-    fn prepare_http_request(
-        &self,
-        url: Url,
-        request: &JsonValue,
-        ctx: &RequestContext,
-    ) -> reqwest::RequestBuilder {
-        let mut req = self.client.post(url).json(request);
-
-        // Add authentication
-        if let Some((header_name, header_value)) = self.auth_header() {
-            req = req.header(header_name, header_value);
-        } else if let Some((hn, hv)) = self.inferred_auth_from_client_headers(ctx) {
-            req = req.header(hn, hv);
-        }
-
-        // Add provider headers
-        for (name, value) in self.provider_headers() {
-            req = req.header(name, value);
-        }
-
-        // Add trace headers from context (filtering restricted ones)
-        use http::header::{CONTENT_LENGTH, CONTENT_TYPE, HOST};
-        for (name, value) in ctx.headers.iter() {
-            if name == HOST
-                || name == CONTENT_LENGTH
-                || name == CONTENT_TYPE
-                || name == AUTHORIZATION
-                || name == X_API_KEY
-            {
-                continue;
-            }
-            req = req.header(name, value);
-        }
-
-        req
-    }
-
-    /// Send the HTTP request and handle network errors
-    async fn send_http_request(
-        &self,
-        request: reqwest::RequestBuilder,
-    ) -> Result<reqwest::Response> {
-        request.send().await.map_err(|e| {
-            Error::ServiceUnavailable(format!(
-                "Failed to send request to {}: {}",
-                self.config.provider, e
-            ))
-        })
-    }
-
-    /// Validate response status and handle errors
-    async fn validate_response_status(
-        &self,
-        response: reqwest::Response,
-    ) -> Result<reqwest::Response> {
-        let status = response.status();
-        if status.is_success() {
-            return Ok(response);
-        }
-
-        let code =
-            StatusCode::from_u16(status.as_u16()).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR);
-
-        let error_body = response
-            .text()
-            .await
-            .unwrap_or_else(|_| "Unable to read error".to_string());
-
-        Err(Error::Rejected(
-            code,
-            format!("{} upstream error: {}", self.config.provider, error_body),
-        ))
-    }
-
-    /// Process response based on whether it's streaming or not
-    async fn process_response(
-        &self,
-        response: reqwest::Response,
-        protocol: Protocol,
-    ) -> Result<ResponseStream> {
-        let headers = self.extract_response_headers(&response);
-        let is_streaming = self.is_streaming_response(&response, protocol);
-
-        if is_streaming {
-            self.process_streaming_response(response, protocol, headers)
-                .await
-        } else {
-            self.process_non_streaming_response(response, headers).await
-        }
-    }
-
-    /// Extract headers from response
-    fn extract_response_headers(
-        &self,
-        response: &reqwest::Response,
-    ) -> std::collections::HashMap<String, String> {
-        let mut headers = std::collections::HashMap::new();
-        for (name, value) in response.headers().iter() {
-            if let Ok(v) = value.to_str() {
-                headers.insert(name.to_string(), v.to_string());
-            }
-        }
-        headers
-    }
-
-    /// Check if response is a streaming response
-    fn is_streaming_response(&self, response: &reqwest::Response, protocol: Protocol) -> bool {
-        // OpenAI Responses are always treated as streaming
-        if protocol == Protocol::OpenAIResponses {
-            return true;
-        }
-
-        // Check Content-Type header for SSE
-        use http::header::CONTENT_TYPE;
-        response
-            .headers()
-            .get(CONTENT_TYPE)
-            .and_then(|v| v.to_str().ok())
-            .map(|v| v.contains("text/event-stream"))
-            .unwrap_or(false)
-    }
-
-    /// Process a streaming SSE response
-    async fn process_streaming_response(
-        &self,
-        response: reqwest::Response,
-        protocol: Protocol,
-        headers: std::collections::HashMap<String, String>,
-    ) -> Result<ResponseStream> {
-        let sse_stream = self.parse_sse_stream(response, protocol).await?;
-
-        // Prepend headers chunk to the stream
-        let stream = futures::stream::once(async move { Ok(ResponseChunk::Headers(headers)) })
-            .chain(sse_stream);
-
-        Ok(Box::pin(stream))
-    }
-
-    /// Process a non-streaming response
-    async fn process_non_streaming_response(
-        &self,
-        response: reqwest::Response,
-        headers: std::collections::HashMap<String, String>,
-    ) -> Result<ResponseStream> {
-        let text = response
-            .text()
-            .await
-            .map_err(|e| Error::Internal(format!("Failed to read response: {e}")))?;
-
-        debug!("Non-streaming response: {}", text);
-
-        let content = if let Ok(body) = serde_json::from_str::<JsonValue>(&text) {
-            body
-        } else {
-            // Fallback: return raw text as content rather than failing
-            JsonValue::String(text)
-        };
-
-        let chunks = vec![
-            Ok(ResponseChunk::Headers(headers)),
-            Ok(ResponseChunk::Content(content)),
-            Ok(ResponseChunk::Stop {
-                reason: StopReason::Complete,
-                error: None,
-                cost: None,
-            }),
-        ];
-
-        Ok(Box::pin(futures::stream::iter(chunks)))
-    }
-
-    /// Parse SSE stream into ResponseChunks
-    async fn parse_sse_stream(
-        &self,
-        response: reqwest::Response,
-        _protocol: Protocol,
-    ) -> Result<ResponseStream> {
-        let stream = response.bytes_stream();
-        let sse_stream = parse_sse(stream);
-
-        let provider = self.config.provider.clone();
-        let stream = sse_stream.map(move |result| {
-            match result {
-                Ok(event) => {
-                    // Handle special [DONE] message
-                    if event.data == "[DONE]" {
-                        return Ok(ResponseChunk::Stop {
-                            reason: StopReason::Complete,
-                            error: None,
-                            cost: None,
-                        });
-                    }
-
-                    // Try to parse as JSON
-                    if let Ok(json) = serde_json::from_str::<JsonValue>(&event.data) {
-                        // Check if this is an error response
-                        if let Some(error) = json.get("error") {
-                            return Ok(ResponseChunk::Stop {
-                                reason: StopReason::Error,
-                                error: Some(error.to_string()),
-                                cost: None,
-                            });
-                        }
-
-                        return Ok(ResponseChunk::Content(json));
-                    }
-
-                    // If not JSON, return as string
-                    Ok(ResponseChunk::Content(JsonValue::String(event.data)))
-                }
-                Err(e) => {
-                    error!("SSE parse error from {}: {}", provider, e);
-                    Ok(ResponseChunk::Stop {
-                        reason: StopReason::Error,
-                        error: Some(format!("Stream error: {e}")),
-                        cost: None,
-                    })
-                }
-            }
-        });
-
-        Ok(Box::pin(stream))
-    }
-
-    /// Execute a non-streaming request
-    async fn execute_non_streaming(
-        &self,
-        ctx: &RequestContext,
-        request_stream: RequestStream,
-    ) -> Result<ResponseStream> {
-        // For non-streaming, we still execute the request but accumulate the response
-        self.execute_streaming(ctx, request_stream).await
-    }
-}
-
-#[async_trait]
-impl Sink for HttpSink {
-    async fn describe(&self) -> SinkDescription {
-        SinkDescription {
-            id: self.config.id.clone(),
-            accepted_protocols: self.config.accepted_protocols.clone(),
-            models: if self.config.models.is_empty() {
-                ModelList::Dynamic
-            } else {
-                ModelList::Static(self.config.models.clone())
-            },
-            capabilities: self.config.capabilities.clone(),
-            cost_structure: self.config.cost_structure.clone(),
-        }
-    }
-
-    async fn probe(&self) -> SinkHealth {
-        // In a real implementation, we might ping the provider's API
-        self.health.read().await.clone()
-    }
-
-    async fn execute(
-        &self,
-        ctx: &RequestContext,
-        mut request_stream: RequestStream,
-    ) -> Result<ResponseStream> {
-        // Check if streaming is requested
-        let first_chunk = request_stream.next().await;
-        if let Some(Ok(ref json)) = first_chunk {
-            let is_streaming = json
-                .get("stream")
-                .and_then(|v| v.as_bool())
-                .unwrap_or(false);
-
-            // Reconstruct the stream with the first chunk
-            let chunks = vec![first_chunk.unwrap()];
-            let remaining = request_stream;
-            let protocol = remaining.protocol();
-            let reconstructed = RequestStream::new(
-                protocol,
-                Box::pin(futures::stream::iter(chunks).chain(remaining)),
-            );
-
-            if is_streaming {
-                self.execute_streaming(ctx, reconstructed).await
-            } else {
-                self.execute_non_streaming(ctx, reconstructed).await
-            }
-        } else {
-            Err(Error::InvalidRequest("Empty request stream".to_string()))
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use gate_core::router::sink::RouterIdentityContext;
-    use gate_core::tracing::CorrelationId;
-
-    fn make_ctx(headers: Vec<(&str, &str)>) -> RequestContext {
-        let mut hmap = http::HeaderMap::new();
-        for (k, v) in headers {
-            let name = http::HeaderName::from_lowercase(k.as_bytes()).unwrap();
-            let val = http::HeaderValue::from_str(v).unwrap();
-            hmap.insert(name, val);
-        }
-        RequestContext {
-            identity: gate_core::access::SubjectIdentity::new(
-                "test",
-                "test",
-                RouterIdentityContext::default(),
-            ),
-            correlation_id: CorrelationId::new(),
-            headers: hmap,
-            query: None,
-            trace_id: None,
-            metadata: Default::default(),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_inferred_auth_from_client_headers_anthropic() {
-        let sink = HttpSink::new(HttpSinkConfig {
-            id: "provider://anthropic".into(),
-            provider: Provider::Anthropic,
-            base_url: "https://api.anthropic.com".into(),
-            api_key: None,
-            models: vec![],
-            timeout: std::time::Duration::from_secs(5),
-            max_retries: 0,
-            accepted_protocols: vec![Protocol::Anthropic],
-            capabilities: SinkCapabilities {
-                supports_streaming: true,
-                supports_batching: false,
-                supports_tools: true,
-                max_context_length: None,
-                modalities: vec!["text".to_string()],
-            },
-            cost_structure: None,
-        })
-        .expect("create sink");
-
-        // x-api-key preferred
-        let ctx = make_ctx(vec![("x-api-key", "sk-ant-abc123")]);
-        let res = sink.inferred_auth_from_client_headers(&ctx);
-        assert!(res.is_some());
-        let (hn, hv) = res.unwrap();
-        assert_eq!(hn, X_API_KEY);
-        assert_eq!(hv, http::HeaderValue::from_static("sk-ant-abc123"));
-
-        // Authorization Bearer fallback
-        let ctx = make_ctx(vec![("authorization", "Bearer sk-ant-oat01-xyz")]);
-        let res = sink.inferred_auth_from_client_headers(&ctx);
-        assert!(res.is_some());
-        let (hn, hv) = res.unwrap();
-        assert_eq!(hn, AUTHORIZATION);
-        assert_eq!(
-            hv,
-            http::HeaderValue::from_static("Bearer sk-ant-oat01-xyz")
-        );
-    }
-
-    #[tokio::test]
-    async fn test_build_url_forwards_query() {
-        let sink = HttpSink::new(HttpSinkConfig {
-            id: "provider://anthropic".into(),
-            provider: Provider::Anthropic,
-            base_url: "https://api.anthropic.com".into(),
-            api_key: None,
-            models: vec![],
-            timeout: std::time::Duration::from_secs(5),
-            max_retries: 0,
-            accepted_protocols: vec![Protocol::Anthropic],
-            capabilities: SinkCapabilities {
-                supports_streaming: true,
-                supports_batching: false,
-                supports_tools: true,
-                max_context_length: None,
-                modalities: vec!["text".to_string()],
-            },
-            cost_structure: None,
-        })
-        .expect("create sink");
-
-        let mut ctx = make_ctx(vec![]);
-        ctx.query = Some("beta=true&foo=bar".to_string());
-
-        let url = sink.build_url(&ctx, Protocol::Anthropic).expect("url");
-        assert_eq!(
-            url.as_str(),
-            "https://api.anthropic.com/v1/messages?beta=true&foo=bar"
-        );
-    }
-}
diff --git a/crates/http/src/sinks/mod.rs b/crates/http/src/sinks/mod.rs
deleted file mode 100644
index 8a9f4e04..00000000
--- a/crates/http/src/sinks/mod.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! HTTP-based sink implementations for external providers
-
-pub mod anthropic;
-pub mod http_sink;
-pub mod openai;
-pub mod response_converter;
-pub mod sse_parser;
-
-pub use http_sink::HttpSink;
-
-pub(crate) const DEFAULT_SINK_TIMEOUT_SECS: u64 = 600;
diff --git a/crates/http/src/sinks/openai.rs b/crates/http/src/sinks/openai.rs
deleted file mode 100644
index f4331b57..00000000
--- a/crates/http/src/sinks/openai.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-//! OpenAI-specific sink factory
-
-use crate::sinks::DEFAULT_SINK_TIMEOUT_SECS;
-
-use super::http_sink::{HttpSink, HttpSinkConfig, Provider};
-use gate_core::Result;
-use gate_core::router::types::{CostStructure, Protocol, SinkCapabilities};
-use rust_decimal::Decimal;
-use std::str::FromStr;
-use std::time::Duration;
-
-/// Configuration for OpenAI provider
-#[derive(Debug, Clone)]
-pub struct OpenAIConfig {
-    pub api_key: Option<String>,
-    pub base_url: Option<String>,
-    pub models: Option<Vec<String>>,
-    pub timeout_seconds: Option<u64>,
-    /// Optional sink ID to use in descriptions/registry keys
-    pub sink_id: Option<String>,
-}
-
-/// Create an OpenAI sink
-pub fn create_sink(config: OpenAIConfig) -> Result<HttpSink> {
-    let base_url = config
-        .base_url
-        .unwrap_or_else(|| "https://api.openai.com".to_string());
-
-    // No hardcoded model list; rely on configured list or dynamic discovery.
-    // Empty list means dynamic support (accept unknown models for routing intent).
-    let models = config.models.unwrap_or_default();
-
-    let timeout = Duration::from_secs(config.timeout_seconds.unwrap_or(DEFAULT_SINK_TIMEOUT_SECS));
-
-    let sink_config = HttpSinkConfig {
-        id: config
-            .sink_id
-            .clone()
-            .unwrap_or_else(|| "provider://openai".to_string()),
-        provider: Provider::OpenAI,
-        base_url,
-        api_key: config.api_key,
-        models,
-        timeout,
-        max_retries: 3,
-        accepted_protocols: vec![
-            Protocol::OpenAIChat,
-            Protocol::OpenAIMessages,
-            Protocol::OpenAICompletions,
-            Protocol::OpenAIResponses,
-        ],
-        capabilities: SinkCapabilities {
-            supports_streaming: true,
-            supports_batching: false,
-            supports_tools: true,
-            max_context_length: Some(128000), // GPT-4 Turbo supports up to 128k
-            modalities: vec!["text".to_string(), "image".to_string()], // GPT-4V supports vision
-        },
-        cost_structure: Some(CostStructure {
-            // Pricing for GPT-4 Turbo
-            input_cost_per_token: Decimal::from_str("0.00001").unwrap(), // $10 per 1M tokens
-            output_cost_per_token: Decimal::from_str("0.00003").unwrap(), // $30 per 1M tokens
-            cached_input_cost_per_token: None, // OpenAI doesn't have cached pricing
-            currency: "USD".to_string(),
-        }),
-    };
-
-    HttpSink::new(sink_config)
-}
-
-/// Create a fallback OpenAI sink with no API key and default base URL.
-/// This sink will accept client-supplied API keys via Authorization headers.
-pub fn create_fallback_sink() -> Result<HttpSink> {
-    let config = OpenAIConfig {
-        api_key: None,
-        base_url: None,
-        models: None,
-        timeout_seconds: Some(DEFAULT_SINK_TIMEOUT_SECS),
-        sink_id: Some("provider://openai/fallback".to_string()),
-    };
-    create_sink(config)
-}
-
-/// Create a fallback Codex sink (ChatGPT Codex backend) with no API key and default base URL.
-/// Accepts OpenAI Responses protocol with dynamic models; expects OAuth Bearer tokens.
-pub fn create_codex_fallback_sink() -> Result<HttpSink> {
-    // Ensure trailing slash so URL::join appends endpoint under codex/
-    let base_url = "https://chatgpt.com/backend-api/codex/".to_string();
-    let timeout = std::time::Duration::from_secs(DEFAULT_SINK_TIMEOUT_SECS);
-
-    let sink_config = super::http_sink::HttpSinkConfig {
-        id: "provider://openai/codex".to_string(),
-        provider: super::http_sink::Provider::OpenAICodex,
-        base_url,
-        api_key: None,
-        models: Vec::new(),
-        timeout,
-        max_retries: 3,
-        accepted_protocols: vec![Protocol::OpenAIResponses],
-        capabilities: SinkCapabilities {
-            supports_streaming: true,
-            supports_batching: false,
-            supports_tools: true,
-            max_context_length: None,
-            modalities: vec!["text".to_string()],
-        },
-        cost_structure: None,
-    };
-
-    super::http_sink::HttpSink::new(sink_config)
-}
diff --git a/crates/http/src/sinks/response_converter.rs b/crates/http/src/sinks/response_converter.rs
deleted file mode 100644
index 4b44de16..00000000
--- a/crates/http/src/sinks/response_converter.rs
+++ /dev/null
@@ -1,289 +0,0 @@
-//! Helper to convert ResponseStream to axum Response
-
-use crate::error::HttpError;
-use axum::response::Json;
-use axum::response::{IntoResponse, Response, Sse, sse::Event};
-use futures::stream::{StreamExt, iter};
-use gate_core::router::types::ActualCost;
-use gate_core::router::{ResponseChunk, ResponseStream};
-use http::header::HeaderName;
-use serde::Serialize;
-use serde::ser::{SerializeMap, Serializer};
-use serde_json::Value as JsonValue;
-use std::collections::HashMap;
-
-const JSON_TYPE_FIELD: &str = "type";
-
-/// Convert a ResponseStream to an axum Response (SSE stream)
-pub async fn response_stream_to_axum(stream: ResponseStream) -> Result<Response, HttpError> {
-    // Peek the first chunk to extract response headers for the HTTP response
-    let mut stream = stream;
-    let head = stream.next().await;
-    let mut response_headers: Option<HashMap<String, String>> = None;
-    let head_item = match head {
-        Some(Ok(ResponseChunk::Headers(h))) => {
-            response_headers = Some(h);
-            None
-        }
-        other => other,
-    };
-
-    let head_stream = iter(head_item.into_iter());
-    let sse_stream = head_stream
-        .chain(stream)
-        .filter(|item| {
-            // Drop any Headers chunks that may appear later
-            let keep = !matches!(item, Ok(ResponseChunk::Headers(_)));
-            std::future::ready(keep)
-        })
-        .map(|result| -> Result<Event, std::convert::Infallible> {
-            match result {
-                Ok(chunk) => match chunk {
-                    // Preserve SSE event names by using payload's "type" field as the SSE event name.
-                    ResponseChunk::Content(json) => {
-                        let mut ev = Event::default();
-                        if let Some(event_name) = json
-                            .as_object()
-                            .and_then(|o| o.get(JSON_TYPE_FIELD))
-                            .and_then(|v| v.as_str())
-                        {
-                            ev = ev.event(event_name);
-                        }
-                        // Ensure the "type" field appears first in the serialized JSON for consistency
-                        let body = if let Some(obj) = json.as_object() {
-                            if obj.get(JSON_TYPE_FIELD).is_some() {
-                                to_json_string(&TypeFirst { obj })
-                            } else {
-                                json.to_string()
-                            }
-                        } else {
-                            json.to_string()
-                        };
-                        Ok(ev.data(body))
-                    }
-                    ResponseChunk::Stop {
-                        reason,
-                        error,
-                        cost,
-                    } => {
-                        let data = DoneEvent {
-                            done: true,
-                            reason: format!("{reason:?}"),
-                            error,
-                            cost,
-                        };
-                        Ok(Event::default().data(to_json_string(&data)))
-                    }
-                    ResponseChunk::Headers(headers) => {
-                        let data = HeadersEvent { headers };
-                        Ok(Event::default().data(to_json_string(&data)))
-                    }
-                    ResponseChunk::Usage {
-                        prompt_tokens,
-                        completion_tokens,
-                    } => {
-                        let data = UsageEvent {
-                            usage: UsagePayload {
-                                prompt_tokens,
-                                completion_tokens,
-                            },
-                        };
-                        Ok(Event::default().data(to_json_string(&data)))
-                    }
-                    ResponseChunk::Metadata(metadata) => {
-                        let data = MetadataEvent { metadata };
-                        Ok(Event::default().data(to_json_string(&data)))
-                    }
-                },
-                Err(e) => {
-                    let data = ErrorEvent {
-                        error: e.to_string(),
-                    };
-                    Ok(Event::default().data(to_json_string(&data)))
-                }
-            }
-        });
-    let mut resp = Sse::new(sse_stream).into_response();
-    if let Some(hdrs) = response_headers {
-        let headers = resp.headers_mut();
-        for (k, v) in hdrs {
-            if let (Ok(name), Ok(value)) = (HeaderName::try_from(k), v.parse()) {
-                headers.insert(name, value);
-            }
-        }
-    }
-    Ok(resp)
-}
-
-/// Convert a ResponseStream representing a non-streaming response to a JSON HTTP response
-pub async fn response_stream_to_json(stream: ResponseStream) -> Result<Response, HttpError> {
-    let mut stream = stream;
-    let head = stream.next().await;
-    let mut response_headers: Option<HashMap<String, String>> = None;
-    let mut last_json: Option<serde_json::Value> = None;
-
-    // Process head
-    if let Some(item) = head {
-        match item {
-            Ok(ResponseChunk::Headers(h)) => {
-                response_headers = Some(h);
-            }
-            Ok(ResponseChunk::Content(json)) => last_json = Some(json),
-            Ok(_) => {}
-            Err(e) => return Err(HttpError::Core(e)),
-        }
-    }
-
-    // Process remainder
-    while let Some(item) = stream.next().await {
-        match item {
-            Ok(ResponseChunk::Headers(_)) => { /* ignore duplicates */ }
-            Ok(ResponseChunk::Content(json)) => last_json = Some(json),
-            Ok(ResponseChunk::Stop {
-                error: Some(err), ..
-            }) => {
-                if last_json.is_none() {
-                    return Err(HttpError::ServiceUnavailable(err));
-                }
-            }
-            Ok(_) => {}
-            Err(e) => return Err(HttpError::Core(e)),
-        }
-    }
-
-    if let Some(json) = last_json {
-        let mut resp = Json(json).into_response();
-        if let Some(hdrs) = response_headers {
-            let headers = resp.headers_mut();
-            for (k, v) in hdrs {
-                if let (Ok(name), Ok(value)) = (HeaderName::try_from(k), v.parse()) {
-                    headers.insert(name, value);
-                }
-            }
-        }
-        Ok(resp)
-    } else {
-        Err(HttpError::ServiceUnavailable(
-            "No content received from sink".to_string(),
-        ))
-    }
-}
-
-#[derive(Serialize)]
-struct DoneEvent {
-    done: bool,
-    reason: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    error: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    cost: Option<ActualCost>,
-}
-
-#[derive(Serialize)]
-struct HeadersEvent {
-    headers: HashMap<String, String>,
-}
-
-#[derive(Serialize)]
-struct UsageEvent {
-    usage: UsagePayload,
-}
-
-#[derive(Serialize)]
-struct UsagePayload {
-    prompt_tokens: u32,
-    completion_tokens: u32,
-}
-
-#[derive(Serialize)]
-struct MetadataEvent {
-    metadata: HashMap<String, JsonValue>,
-}
-
-#[derive(Serialize)]
-struct ErrorEvent {
-    error: String,
-}
-
-fn to_json_string<T: Serialize>(val: &T) -> String {
-    serde_json::to_string(val).unwrap_or_else(|_| "{}".to_string())
-}
-
-struct TypeFirst<'a> {
-    obj: &'a serde_json::Map<String, JsonValue>,
-}
-
-impl<'a> Serialize for TypeFirst<'a> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let len = self.obj.len();
-        let mut map = serializer.serialize_map(Some(len))?;
-        if let Some(typ) = self.obj.get(JSON_TYPE_FIELD) {
-            map.serialize_entry(JSON_TYPE_FIELD, typ)?;
-        }
-        for (k, v) in self.obj.iter() {
-            if k != JSON_TYPE_FIELD {
-                map.serialize_entry(k, v)?;
-            }
-        }
-        map.end()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use futures::stream;
-    use http::header::CONTENT_TYPE;
-    use http_body_util::BodyExt;
-
-    #[tokio::test]
-    async fn test_response_stream_to_json_forwards_headers() {
-        let mut hdrs = std::collections::HashMap::new();
-        hdrs.insert("request-id".to_string(), "abc123".to_string());
-        let json = serde_json::json!({"ok": true});
-        let chunks = vec![
-            Ok(ResponseChunk::Headers(hdrs)),
-            Ok(ResponseChunk::Content(json.clone())),
-            Ok(ResponseChunk::Stop {
-                reason: gate_core::router::types::StopReason::Complete,
-                error: None,
-                cost: None,
-            }),
-        ];
-        let stream = Box::pin(stream::iter(chunks));
-        let resp = response_stream_to_json(stream).await.expect("json resp");
-        assert_eq!(resp.headers().get("request-id").unwrap(), "abc123");
-        let body_bytes = resp.into_body().collect().await.unwrap().to_bytes();
-        let body: serde_json::Value = serde_json::from_slice(&body_bytes).unwrap();
-        assert_eq!(body, json);
-    }
-
-    #[tokio::test]
-    async fn test_response_stream_to_axum_sets_event_name() {
-        let mut hdrs = std::collections::HashMap::new();
-        hdrs.insert("x-test".to_string(), "1".to_string());
-        let json = serde_json::json!({"type": "message_start", "message": {"id": "m"}});
-        let chunks = vec![
-            Ok(ResponseChunk::Headers(hdrs)),
-            Ok(ResponseChunk::Content(json)),
-            Ok(ResponseChunk::Stop {
-                reason: gate_core::router::types::StopReason::Complete,
-                error: None,
-                cost: None,
-            }),
-        ];
-        let stream = Box::pin(stream::iter(chunks));
-        let resp = response_stream_to_axum(stream).await.expect("sse resp");
-        assert_eq!(
-            resp.headers().get(CONTENT_TYPE).unwrap(),
-            "text/event-stream"
-        );
-        let body_bytes = resp.into_body().collect().await.unwrap().to_bytes();
-        let s = String::from_utf8_lossy(&body_bytes);
-        assert!(s.contains("event: message_start"));
-        assert!(s.contains("data: {\"type\":\"message_start\""));
-    }
-}
diff --git a/crates/http/src/sinks/sse_parser.rs b/crates/http/src/sinks/sse_parser.rs
deleted file mode 100644
index 125ce26c..00000000
--- a/crates/http/src/sinks/sse_parser.rs
+++ /dev/null
@@ -1,223 +0,0 @@
-//! Server-Sent Events (SSE) parser for streaming responses
-
-use bytes::Bytes;
-use futures::Stream;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-/// SSE event parsed from the stream
-#[derive(Debug, Clone, Default)]
-pub struct SseEvent {
-    pub event: Option<String>,
-    pub data: String,
-    pub id: Option<String>,
-    pub retry: Option<u64>,
-}
-
-/// Parser state for SSE stream
-pub struct SseParser<S> {
-    stream: S,
-    buffer: String,
-    current_event: SseEvent,
-}
-
-impl<S> SseParser<S>
-where
-    S: Stream<Item = Result<Bytes, reqwest::Error>> + Unpin,
-{
-    pub fn new(stream: S) -> Self {
-        Self {
-            stream,
-            buffer: String::new(),
-            current_event: SseEvent::default(),
-        }
-    }
-
-    fn parse_line(&mut self, line: &str) -> Option<SseEvent> {
-        // Empty line signals end of event
-        if line.is_empty() {
-            if !self.current_event.data.is_empty() {
-                // Remove trailing newline from data
-                if self.current_event.data.ends_with('\n') {
-                    self.current_event.data.pop();
-                }
-                let event = std::mem::take(&mut self.current_event);
-                return Some(event);
-            }
-            return None;
-        }
-
-        // Comment line
-        if line.starts_with(':') {
-            return None;
-        }
-
-        // Parse field
-        let (field, value) = if let Some(colon_pos) = line.find(':') {
-            let field = &line[..colon_pos];
-            let mut value = &line[colon_pos + 1..];
-            // Remove single leading space if present
-            if value.starts_with(' ') {
-                value = &value[1..];
-            }
-            (field, value)
-        } else {
-            (line, "")
-        };
-
-        match field {
-            "event" => self.current_event.event = Some(value.to_string()),
-            "data" => {
-                if !self.current_event.data.is_empty() {
-                    self.current_event.data.push('\n');
-                }
-                self.current_event.data.push_str(value);
-            }
-            "id" => self.current_event.id = Some(value.to_string()),
-            "retry" => {
-                if let Ok(retry) = value.parse::<u64>() {
-                    self.current_event.retry = Some(retry);
-                }
-            }
-            _ => {} // Ignore unknown fields
-        }
-
-        None
-    }
-}
-
-impl<S> Stream for SseParser<S>
-where
-    S: Stream<Item = Result<Bytes, reqwest::Error>> + Unpin,
-{
-    type Item = Result<SseEvent, reqwest::Error>;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        loop {
-            // First, try to parse any complete events from the buffer
-            while let Some(newline_pos) = self.buffer.find('\n') {
-                let line = self.buffer.drain(..=newline_pos).collect::<String>();
-                let line = line.trim_end_matches('\n').trim_end_matches('\r');
-
-                if let Some(event) = self.parse_line(line) {
-                    return Poll::Ready(Some(Ok(event)));
-                }
-            }
-
-            // Need more data
-            match Pin::new(&mut self.stream).poll_next(cx) {
-                Poll::Ready(Some(Ok(bytes))) => {
-                    // Append new data to buffer
-                    self.buffer.push_str(&String::from_utf8_lossy(&bytes));
-                    // Continue loop to parse
-                }
-                Poll::Ready(Some(Err(e))) => {
-                    return Poll::Ready(Some(Err(e)));
-                }
-                Poll::Ready(None) => {
-                    // Stream ended - process any remaining buffer
-                    if !self.buffer.is_empty() {
-                        let remaining = std::mem::take(&mut self.buffer);
-                        if let Some(event) = self.parse_line(&remaining) {
-                            return Poll::Ready(Some(Ok(event)));
-                        }
-                    }
-                    // Check if we have a partial event
-                    if !self.current_event.data.is_empty() {
-                        let event = std::mem::take(&mut self.current_event);
-                        return Poll::Ready(Some(Ok(event)));
-                    }
-                    return Poll::Ready(None);
-                }
-                Poll::Pending => return Poll::Pending,
-            }
-        }
-    }
-}
-
-/// Parse an SSE stream into events
-pub fn parse_sse<S>(stream: S) -> impl Stream<Item = Result<SseEvent, reqwest::Error>>
-where
-    S: Stream<Item = Result<Bytes, reqwest::Error>> + Unpin,
-{
-    SseParser::new(stream)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use futures::{StreamExt, stream};
-
-    #[tokio::test]
-    async fn test_parse_simple_event() {
-        let data = b"data: hello world\n\n";
-        let stream = stream::once(async { Ok(Bytes::from(&data[..])) });
-        let stream = Box::pin(stream);
-        let mut parser = SseParser::new(stream);
-
-        let event = parser.next().await.unwrap().unwrap();
-        assert_eq!(event.data, "hello world");
-        assert_eq!(event.event, None);
-    }
-
-    #[tokio::test]
-    async fn test_parse_multiline_data() {
-        let data = b"data: line 1\ndata: line 2\n\n";
-        let stream = stream::once(async { Ok(Bytes::from(&data[..])) });
-        let stream = Box::pin(stream);
-        let mut parser = SseParser::new(stream);
-
-        let event = parser.next().await.unwrap().unwrap();
-        assert_eq!(event.data, "line 1\nline 2");
-    }
-
-    #[tokio::test]
-    async fn test_parse_with_event_type() {
-        let data = b"event: message\ndata: hello\n\n";
-        let stream = stream::once(async { Ok(Bytes::from(&data[..])) });
-        let stream = Box::pin(stream);
-        let mut parser = SseParser::new(stream);
-
-        let event = parser.next().await.unwrap().unwrap();
-        assert_eq!(event.event, Some("message".to_string()));
-        assert_eq!(event.data, "hello");
-    }
-
-    #[tokio::test]
-    async fn test_parse_with_id() {
-        let data = b"id: 123\ndata: test\n\n";
-        let stream = stream::once(async { Ok(Bytes::from(&data[..])) });
-        let stream = Box::pin(stream);
-        let mut parser = SseParser::new(stream);
-
-        let event = parser.next().await.unwrap().unwrap();
-        assert_eq!(event.id, Some("123".to_string()));
-        assert_eq!(event.data, "test");
-    }
-
-    #[tokio::test]
-    async fn test_ignore_comments() {
-        let data = b": this is a comment\ndata: actual data\n\n";
-        let stream = stream::once(async { Ok(Bytes::from(&data[..])) });
-        let stream = Box::pin(stream);
-        let mut parser = SseParser::new(stream);
-
-        let event = parser.next().await.unwrap().unwrap();
-        assert_eq!(event.data, "actual data");
-    }
-
-    #[tokio::test]
-    async fn test_handle_split_chunks() {
-        let chunk1 = b"data: par";
-        let chunk2 = b"tial\ndata: data\n\n";
-        let stream = stream::iter(vec![
-            Ok(Bytes::from(&chunk1[..])),
-            Ok(Bytes::from(&chunk2[..])),
-        ]);
-        let stream = Box::pin(stream);
-        let mut parser = SseParser::new(stream);
-
-        let event = parser.next().await.unwrap().unwrap();
-        assert_eq!(event.data, "partial\ndata");
-    }
-}
diff --git a/crates/http/src/state.rs b/crates/http/src/state.rs
deleted file mode 100644
index 152b2e1e..00000000
--- a/crates/http/src/state.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-//! Application state management
-
-use gate_core::StateBackend;
-use gate_core::router::prelude::Router;
-use std::sync::Arc;
-
-/// Shared application state
-///
-/// This struct holds the shared state that can be accessed by all handlers
-/// and middleware in the application. It's designed to be extensible through
-/// the use of a generic type parameter.
-#[derive(Clone)]
-pub struct AppState<T = ()> {
-    /// State backend for data persistence
-    pub state_backend: Arc<dyn StateBackend>,
-    /// Router for all routing decisions
-    pub router: Option<Arc<Router>>,
-    /// Custom state data
-    pub data: Arc<T>,
-}
-
-impl<T> AppState<T> {
-    /// Create a new AppState with the given components
-    pub fn new(state_backend: Arc<dyn StateBackend>, data: T) -> Self {
-        Self {
-            state_backend,
-            router: None,
-            data: Arc::new(data),
-        }
-    }
-
-    /// Set the router
-    pub fn with_router(mut self, router: Arc<Router>) -> Self {
-        self.router = Some(router);
-        self
-    }
-}
diff --git a/crates/http/src/streaming.rs b/crates/http/src/streaming.rs
deleted file mode 100644
index 6fdd2d06..00000000
--- a/crates/http/src/streaming.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-//! SSE streaming helpers for converting ResponseChunks to SSE events
-
-use axum::response::sse::Event;
-use gate_core::router::prelude::{Protocol, ResponseChunk};
-use serde_json::{Value as JsonValue, json};
-
-/// Maps a ResponseChunk to an SSE event payload based on the protocol
-pub fn map_to_sse_event(chunk: ResponseChunk, protocol: Protocol) -> Event {
-    let payload = chunk_to_payload(chunk, protocol);
-    let data = serde_json::to_string(&payload).unwrap_or_else(|_| "{}".into());
-    Event::default().data(data)
-}
-
-/// Converts a ResponseChunk to a JSON payload based on the protocol
-fn chunk_to_payload(chunk: ResponseChunk, protocol: Protocol) -> JsonValue {
-    match chunk {
-        ResponseChunk::Content(v) => v,
-        ResponseChunk::Usage {
-            prompt_tokens,
-            completion_tokens,
-        } => match protocol {
-            Protocol::OpenAIChat | Protocol::OpenAIResponses => json!({
-                "usage": {
-                    "prompt_tokens": prompt_tokens,
-                    "completion_tokens": completion_tokens,
-                    "total_tokens": (prompt_tokens + completion_tokens)
-                }
-            }),
-            Protocol::Anthropic => json!({
-                "usage": {
-                    "input_tokens": prompt_tokens,
-                    "output_tokens": completion_tokens
-                }
-            }),
-            _ => json!({
-                "usage": {
-                    "prompt_tokens": prompt_tokens,
-                    "completion_tokens": completion_tokens
-                }
-            }),
-        },
-        ResponseChunk::Stop {
-            error: Some(err), ..
-        } => {
-            // Represent an error event; clients can handle and close
-            json!({"error": err})
-        }
-        ResponseChunk::Stop { .. } => {
-            // Minimal stop signal
-            json!({"stop": true})
-        }
-        ResponseChunk::Headers(_) | ResponseChunk::Metadata(_) => json!({}),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use gate_core::router::types::StopReason;
-    use std::collections::HashMap;
-
-    #[test]
-    fn test_content_chunk_to_payload() {
-        let content = json!({"text": "Hello"});
-        let chunk = ResponseChunk::Content(content.clone());
-        let payload = chunk_to_payload(chunk, Protocol::OpenAIChat);
-        assert_eq!(payload, content);
-    }
-
-    #[test]
-    fn test_usage_chunk_openai() {
-        let chunk = ResponseChunk::Usage {
-            prompt_tokens: 10,
-            completion_tokens: 20,
-        };
-        let payload = chunk_to_payload(chunk, Protocol::OpenAIChat);
-        assert_eq!(payload["usage"]["prompt_tokens"], 10);
-        assert_eq!(payload["usage"]["completion_tokens"], 20);
-        assert_eq!(payload["usage"]["total_tokens"], 30);
-    }
-
-    #[test]
-    fn test_usage_chunk_anthropic() {
-        let chunk = ResponseChunk::Usage {
-            prompt_tokens: 10,
-            completion_tokens: 20,
-        };
-        let payload = chunk_to_payload(chunk, Protocol::Anthropic);
-        assert_eq!(payload["usage"]["input_tokens"], 10);
-        assert_eq!(payload["usage"]["output_tokens"], 20);
-    }
-
-    #[test]
-    fn test_stop_chunk_with_error() {
-        let chunk = ResponseChunk::Stop {
-            reason: StopReason::Error,
-            error: Some("Test error".to_string()),
-            cost: None,
-        };
-        let payload = chunk_to_payload(chunk, Protocol::OpenAIChat);
-        assert_eq!(payload["error"], "Test error");
-    }
-
-    #[test]
-    fn test_stop_chunk_without_error() {
-        let chunk = ResponseChunk::Stop {
-            reason: StopReason::Complete,
-            error: None,
-            cost: None,
-        };
-        let payload = chunk_to_payload(chunk, Protocol::OpenAIChat);
-        assert_eq!(payload["stop"], true);
-    }
-
-    #[test]
-    fn test_headers_and_metadata_chunks() {
-        let headers = ResponseChunk::Headers(HashMap::new());
-        let payload = chunk_to_payload(headers, Protocol::OpenAIChat);
-        assert_eq!(payload, json!({}));
-
-        let metadata = ResponseChunk::Metadata(HashMap::new());
-        let payload = chunk_to_payload(metadata, Protocol::OpenAIChat);
-        assert_eq!(payload, json!({}));
-    }
-
-    #[test]
-    fn test_map_to_sse_event_creates_event() {
-        // Just test that the function creates an Event without errors
-        let chunk = ResponseChunk::Content(json!({"test": "data"}));
-        let _event = map_to_sse_event(chunk, Protocol::OpenAIChat);
-        // Event created successfully
-    }
-}
diff --git a/crates/http/src/types.rs b/crates/http/src/types.rs
deleted file mode 100644
index c18e19f3..00000000
--- a/crates/http/src/types.rs
+++ /dev/null
@@ -1,166 +0,0 @@
-//! Common types used by both client and server
-
-use serde::{Deserialize, Serialize};
-use serde_json::Value as JsonValue;
-
-/// Anthropic Messages request
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AnthropicMessagesRequest {
-    pub model: String,
-    #[serde(default)]
-    pub stream: bool,
-    #[serde(flatten)]
-    pub extra: Option<JsonValue>,
-}
-
-/// OpenAI Chat Completion request
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct OpenAIChatCompletionRequest {
-    pub model: String,
-    #[serde(default)]
-    pub stream: bool,
-    #[serde(flatten)]
-    pub extra: JsonValue,
-}
-
-/// OpenAI Completion request (legacy)
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct OpenAICompletionRequest {
-    pub model: String,
-    #[serde(default)]
-    pub stream: bool,
-    #[serde(flatten)]
-    pub extra: Option<JsonValue>,
-}
-
-/// Registration start request
-#[derive(Debug, Serialize, Deserialize)]
-pub struct RegisterStartRequest {
-    /// Display name for the account
-    pub name: String,
-}
-
-/// Registration start response
-#[derive(Debug, Serialize, Deserialize)]
-pub struct RegisterStartResponse {
-    /// WebAuthn challenge data (as JSON)
-    pub challenge: JsonValue,
-    /// Session ID to track registration
-    pub session_id: String,
-}
-
-/// Registration complete request
-#[derive(Debug, Serialize, Deserialize)]
-pub struct RegisterCompleteRequest {
-    /// Session ID from registration start
-    pub session_id: String,
-    /// WebAuthn credential response (as JSON)
-    pub credential: JsonValue,
-    /// Optional device name
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub device_name: Option<String>,
-    /// Optional bootstrap token (required for first user)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub bootstrap_token: Option<String>,
-}
-
-/// Registration complete response
-#[derive(Debug, Serialize, Deserialize)]
-pub struct RegisterCompleteResponse {
-    /// User ID (same as credential ID)
-    pub user_id: String,
-    /// Display name
-    pub name: String,
-    /// Credential ID
-    pub credential_id: String,
-    /// JWT token for authenticated session
-    pub token: String,
-}
-
-/// Authentication start response
-#[derive(Debug, Serialize, Deserialize)]
-pub struct AuthStartResponse {
-    /// WebAuthn challenge data (as JSON)
-    pub challenge: JsonValue,
-    /// Session ID to track authentication
-    pub session_id: String,
-}
-
-/// Authentication complete request
-#[derive(Debug, Serialize, Deserialize)]
-pub struct AuthCompleteRequest {
-    /// Session ID from auth start
-    pub session_id: String,
-    /// WebAuthn credential response (as JSON)
-    pub credential: JsonValue,
-}
-
-/// Authentication complete response
-#[derive(Debug, Serialize, Deserialize)]
-pub struct AuthCompleteResponse {
-    /// User ID
-    pub user_id: String,
-    /// Display name
-    pub name: String,
-    /// JWT token for authenticated session
-    pub token: String,
-}
-
-/// Configuration response
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ConfigResponse {
-    /// The configuration data as JSON
-    pub config: JsonValue,
-}
-
-/// Configuration update request
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ConfigUpdateRequest {
-    /// The new configuration data as JSON
-    pub config: JsonValue,
-}
-
-/// Configuration patch request for updating specific paths
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ConfigPatchRequest {
-    /// The value to set at the specified path
-    pub value: JsonValue,
-}
-
-/// Health check response
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct HealthCheckResponse {
-    /// Health status (e.g., "healthy", "degraded", "unhealthy")
-    pub status: String,
-    /// ISO 8601 timestamp
-    pub timestamp: String,
-    /// Service name
-    pub service: String,
-    /// Service version
-    pub version: String,
-}
-
-/// Model information in OpenAI format
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ModelInfo {
-    /// Model identifier
-    pub id: String,
-    /// Object type (always "model")
-    pub object: String,
-    /// Owner of the model
-    pub owned_by: String,
-    /// Unix timestamp of when the model was created
-    pub created: i64,
-    /// Optional context length for local models
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub context_length: Option<usize>,
-}
-
-/// OpenAI-compatible models list response
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ModelsListResponse {
-    /// Object type (always "list")
-    pub object: String,
-    /// List of available models
-    pub data: Vec<ModelInfo>,
-}
diff --git a/crates/http/tests/client_tests.rs b/crates/http/tests/client_tests.rs
deleted file mode 100644
index 8401b025..00000000
--- a/crates/http/tests/client_tests.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-//! Integration tests for the Gate HTTP client
-
-#![cfg(feature = "client")]
-
-use gate_http::client::{GateClient, error::ClientError};
-use gate_http::types::AnthropicMessagesRequest;
-use serde_json::json;
-use wiremock::matchers::{header, method, path};
-use wiremock::{Mock, MockServer, ResponseTemplate};
-
-#[tokio::test]
-async fn test_client_builder() {
-    let client = GateClient::builder()
-        .base_url("http://localhost:8080")
-        .api_key("test-key")
-        .build();
-
-    assert!(client.is_ok());
-    let client = client.unwrap();
-    assert_eq!(client.base_url().as_str(), "http://localhost:8080/");
-}
-
-#[tokio::test]
-async fn test_client_builder_requires_base_url() {
-    let result = GateClient::builder().build();
-    assert!(matches!(result, Err(ClientError::Configuration(_))));
-}
-
-#[tokio::test]
-async fn test_anthropic_messages_endpoint() {
-    let mock_server = MockServer::start().await;
-
-    let response_body = json!({
-        "id": "msg_123",
-        "type": "message",
-        "role": "assistant",
-        "content": [{
-            "type": "text",
-            "text": "Hello from test!"
-        }],
-        "model": "claude-3",
-        "stop_reason": "end_turn",
-        "stop_sequence": null,
-        "usage": {
-            "input_tokens": 10,
-            "output_tokens": 15
-        }
-    });
-
-    Mock::given(method("POST"))
-        .and(path("/v1/messages"))
-        .and(header("content-type", "application/json"))
-        .respond_with(ResponseTemplate::new(200).set_body_json(&response_body))
-        .mount(&mock_server)
-        .await;
-
-    let client = GateClient::new(mock_server.uri()).unwrap();
-
-    let request = AnthropicMessagesRequest {
-        model: "claude-3".to_string(),
-        stream: false,
-        extra: None,
-    };
-
-    let response = client.messages(request).await.unwrap();
-    assert_eq!(response["id"], "msg_123");
-    assert_eq!(response["role"], "assistant");
-}
-
-#[tokio::test]
-async fn test_auth_with_api_key() {
-    let mock_server = MockServer::start().await;
-
-    Mock::given(method("POST"))
-        .and(path("/v1/messages"))
-        .and(header("authorization", "Bearer test-api-key"))
-        .respond_with(ResponseTemplate::new(200).set_body_json(json!({})))
-        .mount(&mock_server)
-        .await;
-
-    let client = GateClient::builder()
-        .base_url(mock_server.uri())
-        .api_key("test-api-key")
-        .build()
-        .unwrap();
-
-    let request = AnthropicMessagesRequest {
-        model: "claude-3".to_string(),
-        stream: false,
-        extra: None,
-    };
-
-    let response = client.messages(request).await;
-    assert!(response.is_ok());
-}
-
-#[tokio::test]
-async fn test_error_handling() {
-    let mock_server = MockServer::start().await;
-
-    // Test 401 Unauthorized
-    Mock::given(method("POST"))
-        .and(path("/v1/messages"))
-        .respond_with(ResponseTemplate::new(401).set_body_string("Unauthorized"))
-        .mount(&mock_server)
-        .await;
-
-    let client = GateClient::new(mock_server.uri()).unwrap();
-
-    let request = AnthropicMessagesRequest {
-        model: "claude-3".to_string(),
-        stream: false,
-        extra: None,
-    };
-
-    let result = client.messages(request).await;
-    assert!(matches!(result, Err(ClientError::AuthenticationFailed(_))));
-}
diff --git a/crates/http/tests/integration_test.rs b/crates/http/tests/integration_test.rs
deleted file mode 100644
index 109bca02..00000000
--- a/crates/http/tests/integration_test.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-//! Integration tests for HTTP routes
-
-use axum::http::{HeaderMap, HeaderName, HeaderValue};
-use gate_http::auth::extract_identity;
-
-#[tokio::test]
-async fn test_identity_extraction_with_bearer() {
-    let mut headers = HeaderMap::new();
-    headers.insert(
-        HeaderName::from_static("authorization"),
-        HeaderValue::from_static("Bearer test-jwt-token"),
-    );
-
-    let identity = extract_identity(&headers);
-    assert_eq!(identity.source, "bearer");
-    assert!(!identity.id.is_empty());
-}
-
-#[tokio::test]
-async fn test_identity_extraction_with_basic_auth() {
-    let mut headers = HeaderMap::new();
-    // "testuser:testpass" in base64
-    headers.insert(
-        HeaderName::from_static("authorization"),
-        HeaderValue::from_static("Basic dGVzdHVzZXI6dGVzdHBhc3M="),
-    );
-
-    let identity = extract_identity(&headers);
-    assert_eq!(identity.source, "basic");
-    assert_eq!(identity.id, "testuser");
-}
-
-#[tokio::test]
-async fn test_identity_extraction_with_api_key() {
-    let mut headers = HeaderMap::new();
-    headers.insert(
-        HeaderName::from_static("x-api-key"),
-        HeaderValue::from_static("sk-test-12345"),
-    );
-
-    let identity = extract_identity(&headers);
-    assert_eq!(identity.source, "api_key");
-    assert!(identity.context.api_key_hash.is_some());
-}
-
-#[tokio::test]
-async fn test_identity_extraction_anonymous() {
-    let headers = HeaderMap::new();
-    let identity = extract_identity(&headers);
-    assert_eq!(identity.source, "http");
-    assert_eq!(identity.id, "anonymous");
-}
-
-#[tokio::test]
-async fn test_sse_parser() {
-    use bytes::Bytes;
-    use futures::{StreamExt, stream};
-    use gate_http::sinks::sse_parser::parse_sse;
-
-    let data = b"event: message\ndata: {\"text\": \"hello\"}\nid: 123\n\n";
-    let stream = stream::once(async { Ok::<_, reqwest::Error>(Bytes::from(&data[..])) });
-    let stream = Box::pin(stream);
-    let mut parser = parse_sse(stream);
-
-    let event = parser.next().await.unwrap().unwrap();
-    assert_eq!(event.event, Some("message".to_string()));
-    assert_eq!(event.data, "{\"text\": \"hello\"}");
-    assert_eq!(event.id, Some("123".to_string()));
-}
-
-#[tokio::test]
-async fn test_sse_parser_multiline() {
-    use bytes::Bytes;
-    use futures::{StreamExt, stream};
-    use gate_http::sinks::sse_parser::parse_sse;
-
-    let data = b"data: line 1\ndata: line 2\ndata: line 3\n\n";
-    let stream = stream::once(async { Ok::<_, reqwest::Error>(Bytes::from(&data[..])) });
-    let stream = Box::pin(stream);
-    let mut parser = parse_sse(stream);
-
-    let event = parser.next().await.unwrap().unwrap();
-    assert_eq!(event.data, "line 1\nline 2\nline 3");
-}
-
-#[tokio::test]
-async fn test_sse_parser_split_chunks() {
-    use bytes::Bytes;
-    use futures::{StreamExt, stream};
-    use gate_http::sinks::sse_parser::parse_sse;
-
-    // Simulate data arriving in multiple chunks
-    let chunk1 = b"data: {\"partial\":";
-    let chunk2 = b"\"message\"}\n\n";
-
-    let stream = stream::iter(vec![
-        Ok::<_, reqwest::Error>(Bytes::from(&chunk1[..])),
-        Ok(Bytes::from(&chunk2[..])),
-    ]);
-    let stream = Box::pin(stream);
-
-    let mut parser = parse_sse(stream);
-
-    let event = parser.next().await.unwrap().unwrap();
-    assert_eq!(event.data, "{\"partial\":\"message\"}");
-}
-
-#[tokio::test]
-async fn test_sse_parser_with_comments() {
-    use bytes::Bytes;
-    use futures::{StreamExt, stream};
-    use gate_http::sinks::sse_parser::parse_sse;
-
-    let data = b": this is a comment\ndata: actual data\n\n";
-    let stream = stream::once(async { Ok::<_, reqwest::Error>(Bytes::from(&data[..])) });
-    let stream = Box::pin(stream);
-    let mut parser = parse_sse(stream);
-
-    let event = parser.next().await.unwrap().unwrap();
-    assert_eq!(event.data, "actual data");
-}
-
-#[tokio::test]
-async fn test_sse_parser_with_retry() {
-    use bytes::Bytes;
-    use futures::{StreamExt, stream};
-    use gate_http::sinks::sse_parser::parse_sse;
-
-    let data = b"retry: 5000\ndata: test message\n\n";
-    let stream = stream::once(async { Ok::<_, reqwest::Error>(Bytes::from(&data[..])) });
-    let stream = Box::pin(stream);
-    let mut parser = parse_sse(stream);
-
-    let event = parser.next().await.unwrap().unwrap();
-    assert_eq!(event.retry, Some(5000));
-    assert_eq!(event.data, "test message");
-}
diff --git a/crates/http/tests/routes_build.rs b/crates/http/tests/routes_build.rs
deleted file mode 100644
index 4d18b257..00000000
--- a/crates/http/tests/routes_build.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-use axum::Router;
-
-// Ensure top-level router constructs without overlapping routes or panics
-#[test]
-fn http_routes_build() {
-    let _r: Router<gate_http::AppState<()>> = gate_http::routes::router::<()>();
-}
diff --git a/crates/http/tests/trace_propagation_test.rs b/crates/http/tests/trace_propagation_test.rs
deleted file mode 100644
index 4ece0851..00000000
--- a/crates/http/tests/trace_propagation_test.rs
+++ /dev/null
@@ -1,286 +0,0 @@
-//! Integration tests for W3C trace context propagation
-// TODO: Update this test after API migration
-#![cfg(not(all()))] // Disable for now
-
-use axum::Router;
-use gate_core::tracing::{CorrelationId, trace_context::TraceContext};
-use gate_http::{middleware::correlation::correlation_id_middleware, routes, state::AppState};
-use http::{HeaderMap, HeaderValue, StatusCode};
-use std::sync::Arc;
-use tower::ServiceExt;
-
-/// Test helper to create a test app
-async fn create_test_app() -> Router {
-    let state = AppState::new(());
-
-    Router::new()
-        .merge(routes::health::add_routes(Router::new()))
-        .merge(routes::inference::add_routes(Router::new()))
-        .layer(axum::middleware::from_fn(correlation_id_middleware))
-        .with_state(Arc::new(state))
-}
-
-#[tokio::test]
-async fn test_w3c_traceparent_extraction() {
-    let app = create_test_app().await;
-
-    // Create a W3C traceparent header
-    let traceparent = "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01";
-
-    let response = app
-        .oneshot(
-            http::Request::builder()
-                .uri("/health")
-                .header("traceparent", traceparent)
-                .body(hyper::Body::empty())
-                .unwrap(),
-        )
-        .await
-        .unwrap();
-
-    assert_eq!(response.status(), StatusCode::OK);
-
-    // Check that the response includes the traceparent header
-    let response_traceparent = response
-        .headers()
-        .get("traceparent")
-        .expect("traceparent header should be present");
-
-    assert_eq!(response_traceparent, traceparent);
-}
-
-#[tokio::test]
-async fn test_legacy_correlation_id_extraction() {
-    let app = create_test_app().await;
-
-    // Use a legacy correlation ID
-    let correlation_id = "test-correlation-123";
-
-    let response = app
-        .oneshot(
-            http::Request::builder()
-                .uri("/health")
-                .header("x-correlation-id", correlation_id)
-                .body(hyper::Body::empty())
-                .unwrap(),
-        )
-        .await
-        .unwrap();
-
-    assert_eq!(response.status(), StatusCode::OK);
-
-    // Check that both headers are present in response
-    let response_correlation = response
-        .headers()
-        .get("x-correlation-id")
-        .expect("x-correlation-id header should be present");
-
-    assert_eq!(response_correlation, correlation_id);
-
-    // Should also have a traceparent header
-    assert!(response.headers().get("traceparent").is_some());
-}
-
-#[tokio::test]
-async fn test_trace_context_generation() {
-    let app = create_test_app().await;
-
-    // Request without any correlation headers
-    let response = app
-        .oneshot(
-            http::Request::builder()
-                .uri("/health")
-                .body(hyper::Body::empty())
-                .unwrap(),
-        )
-        .await
-        .unwrap();
-
-    assert_eq!(response.status(), StatusCode::OK);
-
-    // Should have both headers in response
-    let traceparent = response
-        .headers()
-        .get("traceparent")
-        .expect("traceparent header should be generated");
-
-    let correlation_id = response
-        .headers()
-        .get("x-correlation-id")
-        .expect("x-correlation-id header should be generated");
-
-    // Validate traceparent format
-    let traceparent_str = traceparent.to_str().unwrap();
-    assert!(traceparent_str.starts_with("00-"));
-    assert_eq!(traceparent_str.len(), 55); // Format: 00-{32 hex}-{16 hex}-{2 hex}
-
-    // Validate that x-correlation-id matches trace ID from traceparent
-    let trace_ctx = TraceContext::from_traceparent(traceparent_str).unwrap();
-    let trace_id_hex = hex::encode(trace_ctx.trace_id.to_bytes());
-    assert_eq!(correlation_id.to_str().unwrap(), trace_id_hex);
-}
-
-#[tokio::test]
-async fn test_trace_context_priority() {
-    let app = create_test_app().await;
-
-    // Send both headers - traceparent should take priority
-    let traceparent = "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01";
-    let correlation_id = "different-correlation-id";
-
-    let response = app
-        .oneshot(
-            http::Request::builder()
-                .uri("/health")
-                .header("traceparent", traceparent)
-                .header("x-correlation-id", correlation_id)
-                .body(hyper::Body::empty())
-                .unwrap(),
-        )
-        .await
-        .unwrap();
-
-    assert_eq!(response.status(), StatusCode::OK);
-
-    // Response should echo the traceparent
-    let response_traceparent = response
-        .headers()
-        .get("traceparent")
-        .expect("traceparent header should be present");
-
-    assert_eq!(response_traceparent, traceparent);
-
-    // x-correlation-id should be the trace ID from traceparent
-    let response_correlation = response
-        .headers()
-        .get("x-correlation-id")
-        .expect("x-correlation-id header should be present");
-
-    assert_eq!(response_correlation, "4bf92f3577b34da6a3ce929d0e0e4736");
-}
-
-#[tokio::test]
-async fn test_invalid_traceparent_fallback() {
-    let app = create_test_app().await;
-
-    // Send invalid traceparent
-    let invalid_traceparent = "invalid-traceparent-header";
-
-    let response = app
-        .oneshot(
-            http::Request::builder()
-                .uri("/health")
-                .header("traceparent", invalid_traceparent)
-                .body(hyper::Body::empty())
-                .unwrap(),
-        )
-        .await
-        .unwrap();
-
-    assert_eq!(response.status(), StatusCode::OK);
-
-    // Should generate new valid headers
-    let response_traceparent = response
-        .headers()
-        .get("traceparent")
-        .expect("traceparent header should be generated");
-
-    // Should not be the invalid one we sent
-    assert_ne!(response_traceparent, invalid_traceparent);
-
-    // Should be valid format
-    let traceparent_str = response_traceparent.to_str().unwrap();
-    assert!(TraceContext::from_traceparent(traceparent_str).is_ok());
-}
-
-/// Mock upstream handler for testing propagation
-async fn mock_upstream_handler(headers: HeaderMap) -> Result<String, String> {
-    // Check if trace context was propagated
-    if let Some(traceparent) = headers.get("traceparent") {
-        Ok(traceparent.to_str().unwrap().to_string())
-    } else {
-        Err("No traceparent header found".to_string())
-    }
-}
-
-#[cfg(test)]
-mod upstream_propagation_tests {
-    use super::*;
-    use wiremock::matchers::{header, method, path};
-    use wiremock::{Mock, MockServer, ResponseTemplate};
-
-    #[tokio::test]
-    async fn test_upstream_trace_propagation() {
-        // Start a mock upstream server
-        let mock_server = MockServer::start().await;
-
-        // Set up expectation that traceparent header is forwarded
-        Mock::given(method("POST"))
-            .and(path("/v1/chat/completions"))
-            .and(header(
-                "traceparent",
-                "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
-            ))
-            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
-                "id": "test",
-                "choices": [{
-                    "message": {
-                        "content": "test response"
-                    }
-                }]
-            })))
-            .expect(1)
-            .mount(&mock_server)
-            .await;
-
-        // Create app with mock upstream
-        let mut state = AppState::new(());
-        state
-            .upstream_registry
-            .add_upstream(
-                "test".to_string(),
-                gate_core::config::UpstreamConfig {
-                    provider: gate_core::config::Provider::OpenAI,
-                    base_url: mock_server.uri(),
-                    api_key: Some("test-key".to_string()),
-                    models: vec!["test-model".to_string()],
-                    ..Default::default()
-                },
-            )
-            .await
-            .unwrap();
-
-        let app = Router::new()
-            .merge(routes::inference::add_routes(Router::new()))
-            .layer(axum::middleware::from_fn(correlation_id_middleware))
-            .with_state(Arc::new(state));
-
-        // Make request with traceparent
-        let response = app
-            .oneshot(
-                http::Request::builder()
-                    .method("POST")
-                    .uri("/v1/chat/completions")
-                    .header(
-                        "traceparent",
-                        "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
-                    )
-                    .header("content-type", "application/json")
-                    .body(hyper::Body::from(
-                        serde_json::to_string(&serde_json::json!({
-                            "model": "test-model",
-                            "messages": [{"role": "user", "content": "test"}]
-                        }))
-                        .unwrap(),
-                    ))
-                    .unwrap(),
-            )
-            .await
-            .unwrap();
-
-        assert_eq!(response.status(), StatusCode::OK);
-
-        // Verify the mock was called with the traceparent header
-        mock_server.verify().await;
-    }
-}
diff --git a/crates/p2p/Cargo.toml b/crates/p2p/Cargo.toml
deleted file mode 100644
index a99146ed..00000000
--- a/crates/p2p/Cargo.toml
+++ /dev/null
@@ -1,20 +0,0 @@
-[package]
-name = "gate-p2p"
-version.workspace = true
-edition.workspace = true
-authors.workspace = true
-license.workspace = true
-repository.workspace = true
-keywords.workspace = true
-categories.workspace = true
-
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-iroh.workspace = true
-tokio.workspace = true
-
-[dependencies]
-anyhow.workspace = true
-futures.workspace = true
-thiserror.workspace = true
-tokio = { workspace = true, features = ["io-util"] }
-tracing.workspace = true
diff --git a/crates/p2p/README.md b/crates/p2p/README.md
deleted file mode 100644
index d7654396..00000000
--- a/crates/p2p/README.md
+++ /dev/null
@@ -1,78 +0,0 @@
-# gate-p2p
-
-P2P networking layer for Gate using Iroh. Provides encrypted peer-to-peer communication with NAT traversal for sharing AI inference between nodes.
-
-## Responsibilities
-
-- **P2P Router**: Protocol multiplexing over Iroh connections
-- **Stream Utilities**: Bidirectional stream helpers for protocols
-- **Node Identity**: Ed25519-based node identification
-- **NAT Traversal**: Automatic hole-punching via Iroh's QUIC transport
-
-## Organization
-
-```
-src/
-├── router.rs  # Protocol router and configuration
-└── stream.rs  # Stream utilities for bidirectional communication
-```
-
-## Features
-
-- Native only (not available in WASM)
-- Uses Iroh's QUIC-based transport
-- Automatic encryption between peers
-
-## Usage
-
-```rust
-use gate_p2p::{create_router, RouterConfig};
-use iroh::{Endpoint, SecretKey};
-
-// Create P2P endpoint
-let secret_key = SecretKey::generate();
-let endpoint = Endpoint::builder()
-    .secret_key(secret_key)
-    .bind()
-    .await?;
-
-// Create protocol router
-let config = RouterConfig::default();
-let router = create_router(endpoint, config).await?;
-```
-
-## Key Components
-
-### RouterConfig
-Configuration for P2P protocols:
-- Protocol handlers registration
-- Connection settings
-- Timeout configurations
-
-### Stream Utilities
-Helpers for working with Iroh's bidirectional streams:
-- Framed message passing
-- Error handling
-- Graceful shutdown
-
-## Dependencies
-
-- `iroh`: Core P2P networking (native only)
-- `tokio`: Async runtime with IO utilities
-- `futures`: Stream processing
-
-## Protocol Design
-
-Gate uses multiple protocols over P2P:
-- **Control**: Basic connectivity and capability exchange
-- **Inference**: AI model request/response
-- **Relay**: DNS and certificate management
-- **TLS Forwarding**: HTTPS proxy over P2P
-
-Each protocol is identified by ALPN string.
-
-## Risks
-
-- **Native Only**: No WASM support limits browser usage
-- **Network Dependencies**: Requires UDP for QUIC
-- **Key Management**: Node identity must be persisted
\ No newline at end of file
diff --git a/crates/p2p/src/lib.rs b/crates/p2p/src/lib.rs
deleted file mode 100644
index 532c0dbd..00000000
--- a/crates/p2p/src/lib.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//! P2P networking functionality for Gate
-//!
-//! This crate provides P2P utilities using Iroh primitives directly.
-#[macro_use]
-extern crate tracing;
-
-#[cfg(not(target_arch = "wasm32"))]
-pub mod router;
-#[cfg(not(target_arch = "wasm32"))]
-pub mod stream;
-
-// Re-export commonly used types
-#[cfg(not(target_arch = "wasm32"))]
-pub use router::{RouterConfig, create_router};
-
-// Re-export iroh types that are part of our public API
-#[cfg(not(target_arch = "wasm32"))]
-pub use iroh::{
-    Endpoint, NodeAddr, NodeId, PublicKey, SecretKey, discovery,
-    protocol::{ProtocolHandler, Router},
-};
diff --git a/crates/p2p/src/router.rs b/crates/p2p/src/router.rs
deleted file mode 100644
index c05c54e1..00000000
--- a/crates/p2p/src/router.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-//! Simplified P2P router using iroh's Router directly
-
-use iroh::{
-    Endpoint, SecretKey,
-    discovery::ConcurrentDiscovery,
-    protocol::{ProtocolHandler, Router, RouterBuilder},
-};
-use std::net::SocketAddr;
-use thiserror::Error;
-
-/// Configuration for P2P router
-#[derive(Debug, Clone)]
-pub struct RouterConfig {
-    /// Secret key for the node (if not provided, one will be generated)
-    pub secret_key: Option<SecretKey>,
-    /// Bind address for the endpoint
-    pub bind_addrs: Vec<SocketAddr>,
-    /// Enable local network discovery
-    pub enable_discovery: bool,
-}
-
-impl Default for RouterConfig {
-    fn default() -> Self {
-        Self {
-            secret_key: None,
-            bind_addrs: vec![
-                // Default to dual-stack IPv4/IPv6 address
-                SocketAddr::from(([0, 0, 0, 0], 31145)),
-                SocketAddr::from(([0, 0, 0, 0, 0, 0, 0, 0], 31145)),
-            ],
-            enable_discovery: true,
-        }
-    }
-}
-
-#[derive(Debug, Error)]
-pub enum RouterError {
-    #[error("Endpoint bind error: {0}")]
-    EndpointBind(#[from] Box<dyn std::error::Error + Send + Sync>),
-}
-
-type Result<T> = std::result::Result<T, RouterError>;
-
-/// Create and configure a P2P router
-pub async fn create_router(config: RouterConfig) -> Result<RouterBuilder> {
-    // Create endpoint builder
-    let mut builder = Endpoint::builder();
-
-    // Set secret key if provided
-    if let Some(secret_key) = config.secret_key {
-        builder = builder.secret_key(secret_key);
-    }
-
-    // Set bind address if provided
-    for bind_addr in config.bind_addrs {
-        info!("P2P bind address configuration: {}", bind_addr);
-        match bind_addr {
-            SocketAddr::V4(addr) => builder = builder.bind_addr_v4(addr),
-            SocketAddr::V6(addr) => builder = builder.bind_addr_v6(addr),
-        }
-    }
-
-    // Configure discovery
-    if config.enable_discovery {
-        let discovery = ConcurrentDiscovery::default();
-        builder = builder.discovery(discovery);
-    }
-
-    // Build endpoint
-    let endpoint = builder
-        .bind()
-        .await
-        .map_err(|e| RouterError::EndpointBind(Box::new(e)))?;
-
-    Ok(Router::builder(endpoint))
-}
-
-/// Helper function to create and start a router with multiple protocols
-pub async fn start_router<I, T>(config: RouterConfig, protocols: I) -> Result<Router>
-where
-    I: IntoIterator<Item = (Vec<u8>, T)>,
-    T: ProtocolHandler,
-{
-    let mut builder = create_router(config).await?;
-
-    // Add all protocols
-    for (alpn, handler) in protocols {
-        builder = builder.accept(alpn, handler);
-    }
-
-    // Spawn the router
-    Ok(builder.spawn())
-}
diff --git a/crates/p2p/src/stream.rs b/crates/p2p/src/stream.rs
deleted file mode 100644
index 2c4d7f93..00000000
--- a/crates/p2p/src/stream.rs
+++ /dev/null
@@ -1,171 +0,0 @@
-//! Stream utilities for P2P connections
-
-use iroh::endpoint::{RecvStream, SendStream};
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use thiserror::Error;
-use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
-
-/// Wrapper that combines Iroh's RecvStream and SendStream into a single
-/// type that implements AsyncRead + AsyncWrite
-pub struct CombinedStream {
-    recv: RecvStream,
-    send: SendStream,
-}
-
-impl CombinedStream {
-    /// Create a new combined stream from separate recv and send streams
-    pub fn new(recv: RecvStream, send: SendStream) -> Self {
-        Self { recv, send }
-    }
-
-    /// Split the combined stream back into separate recv and send streams
-    pub fn split(self) -> (RecvStream, SendStream) {
-        (self.recv, self.send)
-    }
-
-    /// Get a reference to the receive stream
-    pub fn recv(&self) -> &RecvStream {
-        &self.recv
-    }
-
-    /// Get a mutable reference to the receive stream
-    pub fn recv_mut(&mut self) -> &mut RecvStream {
-        &mut self.recv
-    }
-
-    /// Get a reference to the send stream
-    pub fn send(&self) -> &SendStream {
-        &self.send
-    }
-
-    /// Get a mutable reference to the send stream
-    pub fn send_mut(&mut self) -> &mut SendStream {
-        &mut self.send
-    }
-}
-
-impl AsyncRead for CombinedStream {
-    fn poll_read(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut tokio::io::ReadBuf<'_>,
-    ) -> Poll<io::Result<()>> {
-        match Pin::new(&mut self.recv).poll_read(cx, buf) {
-            Poll::Ready(Ok(())) => Poll::Ready(Ok(())),
-            Poll::Ready(Err(e)) => Poll::Ready(Err(io::Error::other(format!("Read error: {e}")))),
-            Poll::Pending => Poll::Pending,
-        }
-    }
-}
-
-impl AsyncWrite for CombinedStream {
-    fn poll_write(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<io::Result<usize>> {
-        match Pin::new(&mut self.send).poll_write(cx, buf) {
-            Poll::Ready(Ok(n)) => Poll::Ready(Ok(n)),
-            Poll::Ready(Err(e)) => Poll::Ready(Err(io::Error::other(format!("Write error: {e}")))),
-            Poll::Pending => Poll::Pending,
-        }
-    }
-
-    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        match Pin::new(&mut self.send).poll_flush(cx) {
-            Poll::Ready(Ok(())) => Poll::Ready(Ok(())),
-            Poll::Ready(Err(e)) => Poll::Ready(Err(io::Error::other(format!("Flush error: {e}")))),
-            Poll::Pending => Poll::Pending,
-        }
-    }
-
-    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        // Iroh's SendStream doesn't have poll_finish, so we'll just report success
-        // The actual shutdown happens when the stream is dropped
-        Poll::Ready(Ok(()))
-    }
-}
-
-#[derive(Debug, Error)]
-pub enum StreamError {
-    #[error("I/O error: {0}")]
-    Io(#[from] std::io::Error),
-
-    #[error("Operation timed out")]
-    Timeout,
-
-    #[error("Message too large: {0} > {1}")]
-    MessageTooLarge(usize, usize),
-}
-
-type Result<T> = std::result::Result<T, StreamError>;
-
-/// Utilities for working with P2P streams
-pub struct StreamUtils;
-
-impl StreamUtils {
-    /// Copy data between two streams with a timeout
-    pub async fn copy_with_timeout<R, W>(
-        reader: &mut R,
-        writer: &mut W,
-        timeout: std::time::Duration,
-    ) -> Result<u64>
-    where
-        R: AsyncRead + Unpin,
-        W: AsyncWrite + Unpin,
-    {
-        Ok(
-            tokio::time::timeout(timeout, tokio::io::copy(reader, writer))
-                .await
-                .map_err(|_| StreamError::Timeout)??,
-        )
-    }
-
-    /// Copy data bidirectionally between two streams
-    pub async fn copy_bidirectional<A, B>(stream_a: &mut A, stream_b: &mut B) -> Result<(u64, u64)>
-    where
-        A: AsyncRead + AsyncWrite + Unpin,
-        B: AsyncRead + AsyncWrite + Unpin,
-    {
-        Ok(tokio::io::copy_bidirectional(stream_a, stream_b).await?)
-    }
-
-    /// Read a length-prefixed message from a stream
-    pub async fn read_length_prefixed<R>(reader: &mut R, max_len: usize) -> Result<Vec<u8>>
-    where
-        R: AsyncRead + Unpin,
-    {
-        // Read length (4 bytes, big-endian)
-        let mut len_buf = [0u8; 4];
-        reader.read_exact(&mut len_buf).await?;
-        let len = u32::from_be_bytes(len_buf) as usize;
-
-        if len > max_len {
-            return Err(StreamError::MessageTooLarge(len, max_len));
-        }
-
-        // Read message
-        let mut msg = vec![0u8; len];
-        reader.read_exact(&mut msg).await?;
-
-        Ok(msg)
-    }
-
-    /// Write a length-prefixed message to a stream
-    pub async fn write_length_prefixed<W>(writer: &mut W, msg: &[u8]) -> Result<()>
-    where
-        W: AsyncWrite + Unpin,
-    {
-        // Write length (4 bytes, big-endian)
-        let len = msg.len() as u32;
-        writer.write_all(&len.to_be_bytes()).await?;
-
-        // Write message
-        writer.write_all(msg).await?;
-        writer.flush().await?;
-
-        Ok(())
-    }
-}
diff --git a/crates/sqlx/Cargo.toml b/crates/sqlx/Cargo.toml
deleted file mode 100644
index 51c0878f..00000000
--- a/crates/sqlx/Cargo.toml
+++ /dev/null
@@ -1,28 +0,0 @@
-[package]
-name = "gate-sqlx"
-version.workspace = true
-edition.workspace = true
-authors.workspace = true
-license.workspace = true
-repository.workspace = true
-keywords.workspace = true
-categories.workspace = true
-
-[features]
-default = ["sqlite"]
-sqlite = ["sqlx/sqlite"]
-
-[dependencies]
-async-trait.workspace = true
-chrono.workspace = true
-gate-core.workspace = true
-serde.workspace = true
-serde_json.workspace = true
-
-sqlx = { version = "0.8", default-features = false, features = ["runtime-tokio-rustls", "macros", "migrate", "chrono", "uuid"] }
-tokio.workspace = true
-tracing.workspace = true
-
-[dev-dependencies]
-gate-core = { workspace = true, features = ["tests"] }
-tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
diff --git a/crates/sqlx/README.md b/crates/sqlx/README.md
deleted file mode 100644
index 25fbceac..00000000
--- a/crates/sqlx/README.md
+++ /dev/null
@@ -1,79 +0,0 @@
-# gate-sqlx
-
-SQLite database implementation of Gate's `StateBackend` trait using SQLx. Provides production-ready storage for local deployments and Cloudflare D1.
-
-## Responsibilities
-
-- **StateBackend Implementation**: Full implementation for user, API key, usage tracking, and permissions
-- **WebAuthn Storage**: Credential storage for hardware authentication
-- **Database Migrations**: Schema management via SQLx migrate
-- **Connection Pooling**: Efficient database connection management
-- **Type-safe Queries**: Compile-time checked SQL via SQLx macros
-
-## Organization
-
-```
-src/
-├── sqlite.rs    # SQLite implementation of StateBackend
-├── webauthn.rs  # WebAuthn credential storage
-└── common.rs    # Shared types and helpers
-
-migrations/
-├── 0001_initial_schema.sql  # Core tables
-├── 0002_webauthn_schema.sql # WebAuthn tables
-└── 0003_permissions_schema.sql # RBAC permissions
-```
-
-## Features
-
-- `default`: SQLite support
-- `sqlite`: SQLite support
-
-## Usage
-
-```rust
-use gate_sqlx::SqliteStateBackend;
-
-let backend = SqliteStateBackend::new("sqlite://gate.db").await?;
-// Migrations run automatically in new()
-```
-
-## Database Schema
-
-### Core Tables
-- `users`: User accounts with metadata
-- `organizations`: Organization/tenant data
-- `api_keys`: Hashed API keys with configuration
-- `usage_records`: Request usage tracking
-- `providers`: AI provider configurations
-- `models`: Available AI models
-
-### WebAuthn Tables
-- `webauthn_credentials`: Hardware authentication credentials
-
-### Permission Tables
-- `permissions`: Subject-action-object permission tuples for RBAC
-
-## Dependencies
-
-- `sqlx`: Database driver with compile-time checked queries
-- `gate-core`: StateBackend trait and types
-- Runtime: `tokio` with rustls
-
-## Migrations
-
-Migrations are embedded in the binary and run automatically when creating a new backend:
-```rust
-let backend = SqliteStateBackend::new("sqlite://gate.db").await?;
-// Migrations already applied
-```
-
-## Deployment Targets
-
-- **Local/Daemon**: Native SQLite file database
-- **Cloudflare Workers**: D1 (SQLite-compatible cloud database)
-
-## Risks
-
-- **Schema Changes**: Migrations must be backwards compatible
-- **SQLx Offline Mode**: Requires database for compilation unless using offline mode
\ No newline at end of file
diff --git a/crates/sqlx/migrations/0001_initial_schema.sql b/crates/sqlx/migrations/0001_initial_schema.sql
deleted file mode 100644
index b5e8149e..00000000
--- a/crates/sqlx/migrations/0001_initial_schema.sql
+++ /dev/null
@@ -1,78 +0,0 @@
--- Initial schema for Gate (Portable SQL)
-
--- Users table
-CREATE TABLE IF NOT EXISTS users (
-    id TEXT PRIMARY KEY,
-    email TEXT,
-    name TEXT,
-    created_at TEXT NOT NULL,  -- ISO8601 format
-    updated_at TEXT NOT NULL   -- ISO8601 format
-);
-
--- Organizations table
-CREATE TABLE IF NOT EXISTS organizations (
-    id TEXT PRIMARY KEY,
-    name TEXT NOT NULL,
-    created_at TEXT NOT NULL,  -- ISO8601 format
-    settings TEXT              -- JSON as text
-);
-
-CREATE TABLE IF NOT EXISTS grants (
-    user_id TEXT NOT NULL,    -- which user has the grant
-    permission TEXT NOT NULL, -- 'hellas/admin', 'hellas/read',
-    created_at TEXT NOT NULL,    -- ISO8601 format
-    PRIMARY KEY (user_id, permission)
-) WITHOUT ROWID;
-
--- API Keys table
-CREATE TABLE IF NOT EXISTS api_keys (
-    key_hash TEXT PRIMARY KEY,
-    name TEXT NOT NULL,
-    org_id TEXT NOT NULL,
-    config TEXT,               -- JSON as text
-    created_at TEXT NOT NULL,  -- ISO8601 format
-    last_used_at TEXT          -- ISO8601 format
-);
-
--- Providers table
-CREATE TABLE IF NOT EXISTS providers (
-    id TEXT PRIMARY KEY,
-    name TEXT NOT NULL,
-    provider_type TEXT NOT NULL,   -- 'openai', 'anthropic', 'google', 'local', 'custom'
-    config TEXT,                   -- JSON as text
-    enabled INTEGER NOT NULL DEFAULT 1,  -- SQLite uses INTEGER for boolean
-    priority INTEGER NOT NULL DEFAULT 0
-);
-
--- Models table
-CREATE TABLE IF NOT EXISTS models (
-    id TEXT PRIMARY KEY,
-    provider_id TEXT NOT NULL,
-    name TEXT NOT NULL,
-    model_type TEXT NOT NULL,      -- 'chat', 'completion', 'embedding', 'image', 'audio'
-    capabilities TEXT,             -- JSON as text
-    pricing_id TEXT,
-    pricing_config TEXT            -- JSON as text
-);
-
--- Usage records table
-CREATE TABLE IF NOT EXISTS usage_records (
-    id TEXT PRIMARY KEY,
-    org_id TEXT NOT NULL,
-    user_id TEXT NOT NULL,
-    api_key_hash TEXT NOT NULL,
-    request_id TEXT NOT NULL,
-    provider_id TEXT NOT NULL,
-    model_id TEXT NOT NULL,
-    input_tokens INTEGER NOT NULL,
-    output_tokens INTEGER NOT NULL,
-    total_tokens INTEGER NOT NULL,
-    cost REAL NOT NULL,           -- REAL is portable (DOUBLE PRECISION is PostgreSQL-specific)
-    timestamp TEXT NOT NULL,       -- ISO8601 format
-    metadata TEXT                  -- JSON as text
-);
-
--- Indexes
-CREATE INDEX IF NOT EXISTS idx_usage_records_org_id ON usage_records(org_id);
-CREATE INDEX IF NOT EXISTS idx_usage_records_timestamp ON usage_records(timestamp);
-CREATE INDEX IF NOT EXISTS idx_api_keys_org_id ON api_keys(org_id);
\ No newline at end of file
diff --git a/crates/sqlx/migrations/0002_webauthn_schema.sql b/crates/sqlx/migrations/0002_webauthn_schema.sql
deleted file mode 100644
index c6bb31ba..00000000
--- a/crates/sqlx/migrations/0002_webauthn_schema.sql
+++ /dev/null
@@ -1,18 +0,0 @@
--- WebAuthn schema additions
-
--- WebAuthn credentials table
-CREATE TABLE IF NOT EXISTS webauthn_credentials (
-    credential_id TEXT PRIMARY KEY,
-    user_id TEXT NOT NULL,
-    public_key TEXT NOT NULL,
-    aaguid TEXT,
-    counter INTEGER DEFAULT 0,
-    created_at TEXT NOT NULL,  -- ISO8601 format
-    last_used_at TEXT,         -- ISO8601 format
-    device_name TEXT,          -- Optional device nickname
-    FOREIGN KEY (user_id) REFERENCES users(id)
-);
-
--- Indexes
-CREATE INDEX IF NOT EXISTS idx_webauthn_credentials_user_id ON webauthn_credentials(user_id);
-CREATE INDEX IF NOT EXISTS idx_users_name ON users(name);
\ No newline at end of file
diff --git a/crates/sqlx/migrations/0003_permissions_schema.sql b/crates/sqlx/migrations/0003_permissions_schema.sql
deleted file mode 100644
index a4edcbc5..00000000
--- a/crates/sqlx/migrations/0003_permissions_schema.sql
+++ /dev/null
@@ -1,12 +0,0 @@
--- Permissions table for RBAC
-CREATE TABLE IF NOT EXISTS permissions (
-    subject_id TEXT NOT NULL,
-    action TEXT NOT NULL,
-    object TEXT NOT NULL,
-    granted_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    granted_by TEXT,
-    PRIMARY KEY (subject_id, action, object)
-);
-
-CREATE INDEX IF NOT EXISTS idx_permissions_subject ON permissions(subject_id);
-CREATE INDEX IF NOT EXISTS idx_permissions_object ON permissions(object);
\ No newline at end of file
diff --git a/crates/sqlx/migrations/0004_user_status.sql b/crates/sqlx/migrations/0004_user_status.sql
deleted file mode 100644
index 29a983c1..00000000
--- a/crates/sqlx/migrations/0004_user_status.sql
+++ /dev/null
@@ -1,5 +0,0 @@
--- Add disabled_at field to users table
-ALTER TABLE users ADD COLUMN disabled_at TIMESTAMP;
-
--- Index for filtering by disabled status
-CREATE INDEX IF NOT EXISTS idx_users_disabled_at ON users(disabled_at);
\ No newline at end of file
diff --git a/crates/sqlx/src/common.rs b/crates/sqlx/src/common.rs
deleted file mode 100644
index b358efd9..00000000
--- a/crates/sqlx/src/common.rs
+++ /dev/null
@@ -1,208 +0,0 @@
-//! Common types and utilities shared between database implementations
-
-use chrono::{DateTime, Utc};
-use gate_core::{
-    ApiKey, Error, Model, ModelType, Organization, Provider, ProviderType, Result, UsageRecord,
-    User,
-};
-use sqlx::FromRow;
-use std::collections::HashMap;
-
-// Helper functions for timestamp conversion
-pub fn datetime_to_string(dt: DateTime<Utc>) -> String {
-    dt.to_rfc3339()
-}
-
-pub fn string_to_datetime(s: &str) -> Result<DateTime<Utc>> {
-    DateTime::parse_from_rfc3339(s)
-        .map(|dt| dt.with_timezone(&Utc))
-        .map_err(|e| Error::StateError(format!("Invalid timestamp format: {e}")))
-}
-
-// Database row types with FromRow derives
-#[derive(FromRow)]
-pub struct UserRow {
-    pub id: String,
-    pub email: Option<String>,
-    pub name: Option<String>,
-    pub created_at: String,          // ISO8601 format
-    pub updated_at: String,          // ISO8601 format
-    pub disabled_at: Option<String>, // ISO8601 format
-}
-
-#[derive(FromRow)]
-pub struct ApiKeyRow {
-    pub key_hash: String,
-    pub name: String,
-    pub org_id: String,
-    pub config: Option<String>,       // JSON string
-    pub created_at: String,           // ISO8601 format
-    pub last_used_at: Option<String>, // ISO8601 format
-}
-
-#[derive(FromRow)]
-pub struct UsageRecordRow {
-    pub id: String,
-    pub org_id: String,
-    pub user_id: String,
-    pub api_key_hash: String,
-    pub request_id: String,
-    pub provider_id: String,
-    pub model_id: String,
-    pub input_tokens: i64,
-    pub output_tokens: i64,
-    pub total_tokens: i64,
-    pub cost: f64,
-    pub timestamp: String,        // ISO8601 format
-    pub metadata: Option<String>, // JSON string
-}
-
-#[derive(FromRow)]
-pub struct ProviderRow {
-    pub id: String,
-    pub name: String,
-    pub provider_type: String,  // Store as string for portability
-    pub config: Option<String>, // JSON string
-    pub enabled: i32,           // SQLite uses INTEGER for boolean
-    pub priority: i32,
-}
-
-#[derive(FromRow)]
-pub struct ModelRow {
-    pub id: String,
-    pub provider_id: String,
-    pub name: String,
-    pub model_type: String,           // Store as string for portability
-    pub capabilities: Option<String>, // JSON string
-    pub pricing_id: Option<String>,
-    pub pricing_config: Option<String>, // JSON string
-}
-
-#[derive(FromRow)]
-pub struct OrganizationRow {
-    pub id: String,
-    pub name: String,
-    pub created_at: String,       // ISO8601 format
-    pub settings: Option<String>, // JSON string
-}
-
-// Conversion implementations
-impl From<UserRow> for User {
-    fn from(row: UserRow) -> Self {
-        let mut metadata = HashMap::new();
-        if let Some(email) = row.email {
-            metadata.insert("email".to_string(), email);
-        }
-
-        User {
-            id: row.id,
-            name: row.name,
-            created_at: string_to_datetime(&row.created_at).unwrap_or_else(|_| Utc::now()),
-            updated_at: string_to_datetime(&row.updated_at).unwrap_or_else(|_| Utc::now()),
-            disabled_at: row.disabled_at.and_then(|s| string_to_datetime(&s).ok()),
-            metadata,
-        }
-    }
-}
-
-impl From<ApiKeyRow> for ApiKey {
-    fn from(row: ApiKeyRow) -> Self {
-        ApiKey {
-            key_hash: row.key_hash,
-            name: row.name,
-            org_id: row.org_id,
-            config: row.config.and_then(|json| serde_json::from_str(&json).ok()),
-            created_at: string_to_datetime(&row.created_at).unwrap_or_else(|_| Utc::now()),
-            last_used_at: row.last_used_at.and_then(|s| string_to_datetime(&s).ok()),
-        }
-    }
-}
-
-impl From<UsageRecordRow> for UsageRecord {
-    fn from(row: UsageRecordRow) -> Self {
-        let metadata = row
-            .metadata
-            .and_then(|json| serde_json::from_str::<HashMap<String, String>>(&json).ok())
-            .unwrap_or_default();
-
-        UsageRecord {
-            id: row.id,
-            org_id: row.org_id,
-            user_id: row.user_id,
-            api_key_hash: row.api_key_hash,
-            request_id: row.request_id,
-            provider_id: row.provider_id,
-            model_id: row.model_id,
-            input_tokens: row.input_tokens as u64,
-            output_tokens: row.output_tokens as u64,
-            total_tokens: row.total_tokens as u64,
-            cost: row.cost,
-            timestamp: string_to_datetime(&row.timestamp).unwrap_or_else(|_| Utc::now()),
-            metadata,
-        }
-    }
-}
-
-impl From<ProviderRow> for Provider {
-    fn from(row: ProviderRow) -> Self {
-        Provider {
-            id: row.id,
-            name: row.name,
-            provider_type: match row.provider_type.as_str() {
-                "openai" => ProviderType::OpenAI,
-                "anthropic" => ProviderType::Anthropic,
-                "google" => ProviderType::Google,
-                "local" => ProviderType::Local,
-                "custom" => ProviderType::Custom,
-                _ => ProviderType::Unknown,
-            },
-            config: row.config.and_then(|json| serde_json::from_str(&json).ok()),
-            enabled: row.enabled != 0,
-            priority: row.priority as u32,
-        }
-    }
-}
-
-impl From<ModelRow> for Model {
-    fn from(row: ModelRow) -> Self {
-        let capabilities = row
-            .capabilities
-            .and_then(|json| serde_json::from_str::<HashMap<String, String>>(&json).ok())
-            .unwrap_or_default();
-
-        Model {
-            id: row.id,
-            provider_id: row.provider_id,
-            name: row.name,
-            model_type: match row.model_type.as_str() {
-                "chat" => ModelType::Chat,
-                "completion" => ModelType::Completion,
-                "embedding" => ModelType::Embedding,
-                "image" => ModelType::Image,
-                "audio" => ModelType::Audio,
-                _ => ModelType::Unknown,
-            },
-            capabilities,
-            pricing_id: row.pricing_id,
-            pricing_config: row
-                .pricing_config
-                .and_then(|json| serde_json::from_str(&json).ok()),
-        }
-    }
-}
-
-impl From<OrganizationRow> for Organization {
-    fn from(row: OrganizationRow) -> Self {
-        let settings = row
-            .settings
-            .and_then(|json| serde_json::from_str::<HashMap<String, String>>(&json).ok())
-            .unwrap_or_default();
-
-        Organization {
-            id: row.id,
-            name: row.name,
-            created_at: string_to_datetime(&row.created_at).unwrap_or_else(|_| Utc::now()),
-            settings,
-        }
-    }
-}
diff --git a/crates/sqlx/src/lib.rs b/crates/sqlx/src/lib.rs
deleted file mode 100644
index 93269eea..00000000
--- a/crates/sqlx/src/lib.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-extern crate tracing;
-
-mod common;
-mod webauthn;
-
-#[cfg(feature = "sqlite")]
-mod sqlite;
-
-#[cfg(feature = "sqlite")]
-pub use webauthn::{SqlxWebAuthnBackend, StoredCredential};
-
-#[cfg(feature = "sqlite")]
-pub use sqlite::SqliteStateBackend;
-
-#[cfg(feature = "sqlite")]
-pub type SqliteWebAuthnBackend = SqlxWebAuthnBackend<sqlx::Sqlite>;
diff --git a/crates/sqlx/src/sqlite.rs b/crates/sqlx/src/sqlite.rs
deleted file mode 100644
index dec4ffbd..00000000
--- a/crates/sqlx/src/sqlite.rs
+++ /dev/null
@@ -1,455 +0,0 @@
-use crate::common::{
-    ApiKeyRow, ModelRow, OrganizationRow, ProviderRow, UsageRecordRow, UserRow, datetime_to_string,
-    string_to_datetime,
-};
-use async_trait::async_trait;
-use gate_core::{
-    ApiKey, Error, Model, Organization, Provider, Result, StateBackend, TimeRange, UsageRecord,
-    User,
-    access::{Action, ObjectIdentity},
-};
-use sqlx::{Pool, Sqlite};
-
-pub struct SqliteStateBackend {
-    pool: Pool<Sqlite>,
-}
-
-impl SqliteStateBackend {
-    pub async fn new(database_url: &str) -> Result<Self> {
-        use sqlx::sqlite::SqliteConnectOptions;
-        use std::str::FromStr;
-
-        let options = SqliteConnectOptions::from_str(database_url)
-            .map_err(|e| Error::StateError(format!("Invalid database URL: {e}")))?
-            .create_if_missing(true);
-
-        let pool = sqlx::SqlitePool::connect_with(options)
-            .await
-            .map_err(|e| Error::StateError(format!("Failed to connect to database: {e}")))?;
-
-        sqlx::migrate!("./migrations")
-            .run(&pool)
-            .await
-            .map_err(|e| Error::StateError(format!("Failed to run migrations: {e}")))?;
-
-        Ok(Self { pool })
-    }
-
-    pub fn from_pool(pool: Pool<Sqlite>) -> Self {
-        Self { pool }
-    }
-
-    pub fn pool(&self) -> &Pool<Sqlite> {
-        &self.pool
-    }
-}
-
-#[async_trait]
-impl StateBackend for SqliteStateBackend {
-    // User management
-    async fn get_user(&self, user_id: &str) -> Result<Option<User>> {
-        let row = sqlx::query_as::<_, UserRow>(
-            "SELECT id, email, name, created_at, updated_at, disabled_at FROM users WHERE id = ?1",
-        )
-        .bind(user_id)
-        .fetch_optional(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to get user: {e}")))?;
-
-        Ok(row.map(User::from))
-    }
-
-    async fn get_user_by_id(&self, user_id: &str) -> Result<Option<User>> {
-        self.get_user(user_id).await
-    }
-
-    async fn create_user(&self, user: &User) -> Result<()> {
-        let email = user.metadata.get("email").map(|s| s.as_str());
-        let created_at = datetime_to_string(user.created_at);
-        let updated_at = datetime_to_string(user.updated_at);
-
-        sqlx::query(
-            "INSERT INTO users (id, email, name, created_at, updated_at, disabled_at) VALUES (?1, ?2, ?3, ?4, ?5, ?6)",
-        )
-        .bind(&user.id)
-        .bind(email)
-        .bind(&user.name)
-        .bind(&created_at)
-        .bind(&updated_at)
-        .bind(user.disabled_at.map(datetime_to_string))
-        .execute(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to create user: {e}")))?;
-
-        Ok(())
-    }
-
-    async fn update_user(&self, user: &User) -> Result<()> {
-        let email = user.metadata.get("email").map(|s| s.as_str());
-        let updated_at = datetime_to_string(user.updated_at);
-
-        sqlx::query("UPDATE users SET email = ?2, name = ?3, updated_at = ?4, disabled_at = ?5 WHERE id = ?1")
-            .bind(&user.id)
-            .bind(email)
-            .bind(&user.name)
-            .bind(&updated_at)
-            .bind(user.disabled_at.map(datetime_to_string))
-            .execute(&self.pool)
-            .await
-            .map_err(|e| Error::StateError(format!("Failed to update user: {e}")))?;
-
-        Ok(())
-    }
-
-    async fn delete_user(&self, user_id: &str) -> Result<()> {
-        sqlx::query("DELETE FROM users WHERE id = ?1")
-            .bind(user_id)
-            .execute(&self.pool)
-            .await
-            .map_err(|e| Error::StateError(format!("Failed to delete user: {e}")))?;
-
-        Ok(())
-    }
-
-    async fn list_users(&self) -> Result<Vec<User>> {
-        let rows = sqlx::query_as::<_, UserRow>(
-            "SELECT id, email, name, created_at, updated_at, disabled_at FROM users ORDER BY created_at DESC",
-        )
-        .fetch_all(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to list users: {e}")))?;
-
-        Ok(rows.into_iter().map(User::from).collect())
-    }
-
-    // API key management
-    async fn get_api_key(&self, key_hash: &str) -> Result<Option<ApiKey>> {
-        let row = sqlx::query_as::<_, ApiKeyRow>(
-            "SELECT key_hash, name, org_id, config, created_at, last_used_at FROM api_keys WHERE key_hash = ?1",
-        )
-        .bind(key_hash)
-        .fetch_optional(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to get API key: {e}")))?;
-
-        Ok(row.map(ApiKey::from))
-    }
-
-    async fn create_api_key(&self, key: &ApiKey, _raw_key: &str) -> Result<()> {
-        let config = key
-            .config
-            .as_ref()
-            .map(serde_json::to_string)
-            .transpose()
-            .map_err(|e| Error::StateError(format!("Failed to serialize config: {e}")))?;
-        let created_at = datetime_to_string(key.created_at);
-        let last_used_at = key.last_used_at.map(datetime_to_string);
-
-        sqlx::query(
-            "INSERT INTO api_keys (key_hash, name, org_id, config, created_at, last_used_at) 
-             VALUES (?1, ?2, ?3, ?4, ?5, ?6)",
-        )
-        .bind(&key.key_hash)
-        .bind(&key.name)
-        .bind(&key.org_id)
-        .bind(config)
-        .bind(&created_at)
-        .bind(last_used_at)
-        .execute(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to create API key: {e}")))?;
-
-        Ok(())
-    }
-
-    async fn list_api_keys(&self, org_id: &str) -> Result<Vec<ApiKey>> {
-        let rows = sqlx::query_as::<_, ApiKeyRow>(
-            "SELECT key_hash, name, org_id, config, created_at, last_used_at 
-             FROM api_keys WHERE org_id = ?1 ORDER BY created_at DESC",
-        )
-        .bind(org_id)
-        .fetch_all(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to list API keys: {e}")))?;
-
-        Ok(rows.into_iter().map(ApiKey::from).collect())
-    }
-
-    async fn delete_api_key(&self, key_hash: &str) -> Result<()> {
-        sqlx::query("DELETE FROM api_keys WHERE key_hash = ?1")
-            .bind(key_hash)
-            .execute(&self.pool)
-            .await
-            .map_err(|e| Error::StateError(format!("Failed to delete API key: {e}")))?;
-
-        Ok(())
-    }
-
-    // Usage tracking
-    async fn record_usage(&self, usage: &UsageRecord) -> Result<()> {
-        let metadata = serde_json::to_string(&usage.metadata)
-            .map_err(|e| Error::StateError(format!("Failed to serialize metadata: {e}")))?;
-        let timestamp = datetime_to_string(usage.timestamp);
-
-        sqlx::query(
-            "INSERT INTO usage_records 
-             (id, org_id, user_id, api_key_hash, request_id, provider_id, model_id, 
-              input_tokens, output_tokens, total_tokens, cost, timestamp, metadata) 
-             VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13)",
-        )
-        .bind(&usage.id)
-        .bind(&usage.org_id)
-        .bind(&usage.user_id)
-        .bind(&usage.api_key_hash)
-        .bind(&usage.request_id)
-        .bind(&usage.provider_id)
-        .bind(&usage.model_id)
-        .bind(usage.input_tokens as i64)
-        .bind(usage.output_tokens as i64)
-        .bind(usage.total_tokens as i64)
-        .bind(usage.cost)
-        .bind(&timestamp)
-        .bind(&metadata)
-        .execute(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to record usage: {e}")))?;
-
-        Ok(())
-    }
-
-    async fn get_usage(&self, org_id: &str, range: &TimeRange) -> Result<Vec<UsageRecord>> {
-        let start = datetime_to_string(range.start);
-        let end = datetime_to_string(range.end);
-
-        let rows = sqlx::query_as::<_, UsageRecordRow>(
-            "SELECT id, org_id, user_id, api_key_hash, request_id, provider_id, model_id, 
-             input_tokens, output_tokens, total_tokens, cost, timestamp, metadata 
-             FROM usage_records WHERE org_id = ?1 AND timestamp >= ?2 AND timestamp <= ?3 
-             ORDER BY timestamp DESC",
-        )
-        .bind(org_id)
-        .bind(&start)
-        .bind(&end)
-        .fetch_all(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to get usage: {e}")))?;
-
-        Ok(rows.into_iter().map(UsageRecord::from).collect())
-    }
-
-    // Provider management
-    async fn get_provider(&self, id: &str) -> Result<Option<Provider>> {
-        let row = sqlx::query_as::<_, ProviderRow>(
-            "SELECT id, name, provider_type, config, enabled, priority FROM providers WHERE id = ?1",
-        )
-        .bind(id)
-        .fetch_optional(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to get provider: {e}")))?;
-
-        Ok(row.map(Provider::from))
-    }
-
-    async fn list_providers(&self) -> Result<Vec<Provider>> {
-        let rows = sqlx::query_as::<_, ProviderRow>(
-            "SELECT id, name, provider_type, config, enabled, priority 
-             FROM providers ORDER BY priority ASC",
-        )
-        .fetch_all(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to list providers: {e}")))?;
-
-        Ok(rows.into_iter().map(Provider::from).collect())
-    }
-
-    // Model management
-    async fn get_model(&self, id: &str) -> Result<Option<Model>> {
-        let row = sqlx::query_as::<_, ModelRow>(
-            "SELECT id, provider_id, name, model_type, capabilities, pricing_id, pricing_config 
-             FROM models WHERE id = ?1",
-        )
-        .bind(id)
-        .fetch_optional(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to get model: {e}")))?;
-
-        Ok(row.map(Model::from))
-    }
-
-    async fn list_models(&self) -> Result<Vec<Model>> {
-        let rows = sqlx::query_as::<_, ModelRow>(
-            "SELECT id, provider_id, name, model_type, capabilities, pricing_id, pricing_config 
-             FROM models ORDER BY provider_id, name",
-        )
-        .fetch_all(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to list models: {e}")))?;
-
-        Ok(rows.into_iter().map(Model::from).collect())
-    }
-
-    // Organization management
-    async fn get_organization(&self, id: &str) -> Result<Option<Organization>> {
-        let row = sqlx::query_as::<_, OrganizationRow>(
-            "SELECT id, name, created_at, settings FROM organizations WHERE id = ?1",
-        )
-        .bind(id)
-        .fetch_optional(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to get organization: {e}")))?;
-
-        Ok(row.map(Organization::from))
-    }
-
-    async fn create_organization(&self, org: &Organization) -> Result<()> {
-        let settings = serde_json::to_string(&org.settings)
-            .map_err(|e| Error::StateError(format!("Failed to serialize settings: {e}")))?;
-        let created_at = datetime_to_string(org.created_at);
-
-        sqlx::query(
-            "INSERT INTO organizations (id, name, created_at, settings) VALUES (?1, ?2, ?3, ?4)",
-        )
-        .bind(&org.id)
-        .bind(&org.name)
-        .bind(&created_at)
-        .bind(&settings)
-        .execute(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to create organization: {e}")))?;
-
-        Ok(())
-    }
-
-    // Permission management
-    async fn has_permission(
-        &self,
-        subject_id: &str,
-        action: &Action,
-        object: &ObjectIdentity,
-    ) -> Result<bool> {
-        let action_str = serde_json::to_string(action)
-            .map_err(|e| Error::StateError(format!("Failed to serialize action: {e}")))?;
-        let object_str = format!("{object}");
-
-        let result: (i64,) = sqlx::query_as(
-            r#"
-            SELECT COUNT(*)
-            FROM permissions
-            WHERE subject_id = ?1 AND action = ?2 AND object = ?3
-            "#,
-        )
-        .bind(subject_id)
-        .bind(action_str)
-        .bind(object_str)
-        .fetch_one(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to check permission: {e}")))?;
-
-        Ok(result.0 > 0)
-    }
-
-    async fn grant_permission(
-        &self,
-        subject_id: &str,
-        action: &Action,
-        object: &ObjectIdentity,
-    ) -> Result<()> {
-        let action_str = serde_json::to_string(action)
-            .map_err(|e| Error::StateError(format!("Failed to serialize action: {e}")))?;
-        let object_str = format!("{object}");
-
-        sqlx::query(
-            r#"
-            INSERT OR REPLACE INTO permissions (subject_id, action, object, granted_at)
-            VALUES (?1, ?2, ?3, CURRENT_TIMESTAMP)
-            "#,
-        )
-        .bind(subject_id)
-        .bind(action_str)
-        .bind(object_str)
-        .execute(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to grant permission: {e}")))?;
-
-        Ok(())
-    }
-
-    async fn remove_permission(
-        &self,
-        subject_id: &str,
-        action: &Action,
-        object: &ObjectIdentity,
-    ) -> Result<()> {
-        let action_str = serde_json::to_string(action)
-            .map_err(|e| Error::StateError(format!("Failed to serialize action: {e}")))?;
-        let object_str = format!("{object}");
-
-        sqlx::query(
-            r#"
-            DELETE FROM permissions
-            WHERE subject_id = ?1 AND action = ?2 AND object = ?3
-            "#,
-        )
-        .bind(subject_id)
-        .bind(action_str)
-        .bind(object_str)
-        .execute(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to remove permission: {e}")))?;
-
-        Ok(())
-    }
-
-    async fn list_user_permissions(
-        &self,
-        user_id: &str,
-    ) -> Result<Vec<(String, String, chrono::DateTime<chrono::Utc>)>> {
-        #[derive(sqlx::FromRow)]
-        struct PermissionRow {
-            action: String,
-            object: String,
-            granted_at: String,
-        }
-
-        let rows = sqlx::query_as::<_, PermissionRow>(
-            "
-            SELECT action, object, granted_at
-            FROM permissions
-            WHERE subject_id = ?1
-            ORDER BY granted_at DESC
-        ",
-        )
-        .bind(user_id)
-        .fetch_all(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to list permissions: {e}")))?;
-
-        let permissions = rows
-            .into_iter()
-            .map(|row| {
-                let granted_at =
-                    string_to_datetime(&row.granted_at).unwrap_or_else(|_| chrono::Utc::now());
-                (row.action, row.object, granted_at)
-            })
-            .collect();
-
-        Ok(permissions)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use gate_core::tests::state::StateBackendTestSuite;
-
-    async fn setup_sqlite_backend() -> SqliteStateBackend {
-        SqliteStateBackend::new(":memory:").await.unwrap()
-    }
-
-    #[tokio::test]
-    async fn test_sqlite_compliance() {
-        let backend = setup_sqlite_backend().await;
-        let suite = StateBackendTestSuite::new(backend);
-        suite.run_all_tests().await.expect("All tests should pass");
-    }
-}
diff --git a/crates/sqlx/src/webauthn.rs b/crates/sqlx/src/webauthn.rs
deleted file mode 100644
index 6d65f20a..00000000
--- a/crates/sqlx/src/webauthn.rs
+++ /dev/null
@@ -1,166 +0,0 @@
-//! WebAuthn backend implementation for SQLx
-
-use chrono::{DateTime, Utc};
-use gate_core::{Error, Result};
-use serde::{Deserialize, Serialize};
-use sqlx::{Database, Executor, FromRow, Pool};
-
-use crate::common::{datetime_to_string, string_to_datetime};
-
-/// WebAuthn credential stored in database
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct StoredCredential {
-    pub credential_id: String,
-    pub user_id: String,
-    pub public_key: Vec<u8>,
-    pub aaguid: Option<Vec<u8>>,
-    pub counter: u32,
-    pub created_at: DateTime<Utc>,
-    pub last_used_at: Option<DateTime<Utc>>,
-    pub device_name: Option<String>,
-}
-
-/// Database row type for WebAuthn credentials
-#[derive(FromRow)]
-pub struct WebAuthnCredentialRow {
-    pub credential_id: String,
-    pub user_id: String,
-    pub public_key: Vec<u8>,
-    pub aaguid: Option<Vec<u8>>,
-    pub counter: i32,
-    pub created_at: String,
-    pub last_used_at: Option<String>,
-    pub device_name: Option<String>,
-}
-
-impl From<WebAuthnCredentialRow> for StoredCredential {
-    fn from(row: WebAuthnCredentialRow) -> Self {
-        StoredCredential {
-            credential_id: row.credential_id,
-            user_id: row.user_id,
-            public_key: row.public_key,
-            aaguid: row.aaguid,
-            counter: row.counter as u32,
-            created_at: string_to_datetime(&row.created_at).unwrap_or_else(|_| chrono::Utc::now()),
-            last_used_at: row.last_used_at.and_then(|s| string_to_datetime(&s).ok()),
-            device_name: row.device_name,
-        }
-    }
-}
-
-/// SQLx implementation of WebAuthnBackend
-pub struct SqlxWebAuthnBackend<DB: Database> {
-    pool: Pool<DB>,
-}
-
-impl<DB: Database> SqlxWebAuthnBackend<DB> {
-    pub fn new(pool: Pool<DB>) -> Self {
-        Self { pool }
-    }
-}
-
-impl<DB> SqlxWebAuthnBackend<DB>
-where
-    DB: Database,
-    for<'c> &'c mut <DB as Database>::Connection: Executor<'c, Database = DB>,
-    for<'r> WebAuthnCredentialRow: FromRow<'r, DB::Row>,
-    // Required for async_trait with generic parameters
-    DB: Send + Sync,
-    DB::Connection: Send,
-    // Required for parameter binding
-    for<'q> String: sqlx::Encode<'q, DB> + sqlx::Type<DB>,
-    for<'q> &'q str: sqlx::Encode<'q, DB> + sqlx::Type<DB>,
-    for<'q> Option<String>: sqlx::Encode<'q, DB> + sqlx::Type<DB>,
-    for<'q> Vec<u8>: sqlx::Encode<'q, DB> + sqlx::Type<DB>,
-    for<'q> Option<Vec<u8>>: sqlx::Encode<'q, DB> + sqlx::Type<DB>,
-    for<'q> i32: sqlx::Encode<'q, DB> + sqlx::Type<DB>,
-    // Required for queries
-    for<'q> <DB as Database>::Arguments<'q>: sqlx::IntoArguments<'q, DB>,
-{
-    pub async fn store_webauthn_credential(&self, credential: &StoredCredential) -> Result<()> {
-        sqlx::query(
-            "INSERT INTO webauthn_credentials (credential_id, user_id, public_key, aaguid, counter, created_at, last_used_at, device_name) 
-             VALUES ($1, $2, $3, $4, $5, $6, $7, $8)"
-        )
-        .bind(&credential.credential_id)
-        .bind(&credential.user_id)
-        .bind(&credential.public_key)
-        .bind(&credential.aaguid)
-        .bind(credential.counter as i32)
-        .bind(datetime_to_string(credential.created_at))
-        .bind(credential.last_used_at.map(datetime_to_string))
-        .bind(&credential.device_name)
-        .execute(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to store credential: {e}")))?;
-
-        Ok(())
-    }
-
-    pub async fn get_webauthn_credential(
-        &self,
-        credential_id: &str,
-    ) -> Result<Option<StoredCredential>> {
-        let row = sqlx::query_as::<_, WebAuthnCredentialRow>(
-            "SELECT credential_id, user_id, public_key, aaguid, counter, created_at, last_used_at, device_name 
-             FROM webauthn_credentials WHERE credential_id = $1"
-        )
-        .bind(credential_id)
-        .fetch_optional(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to get credential: {e}")))?;
-
-        Ok(row.map(Into::into))
-    }
-
-    pub async fn list_user_credentials(&self, user_id: &str) -> Result<Vec<StoredCredential>> {
-        let rows = sqlx::query_as::<_, WebAuthnCredentialRow>(
-            "SELECT credential_id, user_id, public_key, aaguid, counter, created_at, last_used_at, device_name 
-             FROM webauthn_credentials WHERE user_id = $1 ORDER BY created_at DESC"
-        )
-        .bind(user_id)
-        .fetch_all(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to list user credentials: {e}")))?;
-
-        Ok(rows.into_iter().map(Into::into).collect())
-    }
-
-    pub async fn list_all_credentials(&self) -> Result<Vec<StoredCredential>> {
-        let rows = sqlx::query_as::<_, WebAuthnCredentialRow>(
-            "SELECT credential_id, user_id, public_key, aaguid, counter, created_at, last_used_at, device_name 
-             FROM webauthn_credentials ORDER BY created_at DESC"
-        )
-        .fetch_all(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to list all credentials: {e}")))?;
-
-        Ok(rows.into_iter().map(Into::into).collect())
-    }
-
-    pub async fn update_credential_counter(&self, credential_id: &str, counter: u32) -> Result<()> {
-        let now = datetime_to_string(chrono::Utc::now());
-
-        sqlx::query(
-            "UPDATE webauthn_credentials SET counter = $1, last_used_at = $2 WHERE credential_id = $3"
-        )
-        .bind(counter as i32)
-        .bind(now)
-        .bind(credential_id)
-        .execute(&self.pool)
-        .await
-        .map_err(|e| Error::StateError(format!("Failed to update credential counter: {e}")))?;
-
-        Ok(())
-    }
-
-    pub async fn delete_credential(&self, credential_id: &str) -> Result<()> {
-        sqlx::query("DELETE FROM webauthn_credentials WHERE credential_id = $1")
-            .bind(credential_id)
-            .execute(&self.pool)
-            .await
-            .map_err(|e| Error::StateError(format!("Failed to delete credential: {e}")))?;
-
-        Ok(())
-    }
-}
diff --git a/crates/tlsforward/Cargo.toml b/crates/tlsforward/Cargo.toml
deleted file mode 100644
index 6fe0b5e2..00000000
--- a/crates/tlsforward/Cargo.toml
+++ /dev/null
@@ -1,119 +0,0 @@
-[package]
-name = "gate-tlsforward"
-version.workspace = true
-edition.workspace = true
-authors.workspace = true
-license.workspace = true
-repository.workspace = true
-keywords.workspace = true
-categories.workspace = true
-
-[[bin]]
-name = "gate-tlsforward"
-required-features = ["server"]
-
-[features]
-default = ["client", "server"]
-client = [
-    "dep:hyper-util",
-    "dep:http-body-util",
-    "dep:tokio-rustls",
-    "dep:gate-http",
-    "dep:rcgen",
-    "instant-acme/ring",
-    "instant-acme/hyper-rustls",
-]
-server = [
-    "client",
-    "dep:tokio-rustls",
-    "dep:x509-parser",
-    "dep:config",
-    "dep:clap",
-    "dep:tracing-subscriber",
-    "dep:cloudflare",
-    "dep:uuid",
-    "dep:axum",
-    "dep:tower",
-    "dep:trust-dns-resolver",
-]
-
-[dependencies]
-# Error handling and logging
-anyhow = { workspace = true }
-async-trait = { workspace = true }
-
-# HTTP server dependencies
-axum = { workspace = true, optional = true }
-
-# Core dependencies (needed for protocol)
-bytes = { workspace = true }
-chrono = { workspace = true }
-
-# CLI parsing
-clap = { workspace = true, optional = true }
-
-# DNS management
-cloudflare = { version = "0.14", optional = true }
-
-# Configuration
-config = { workspace = true, optional = true }
-dashmap = "6.2"
-deadpool = "0.13"
-directories = "6"
-futures = { workspace = true }
-
-# gate-dynconfig removed - using standard config crate instead
-
-# HTTP server dependency
-gate-http = { path = "../http", optional = true }
-
-# Core dependency with tracing
-gate-core = { workspace = true, features = ["tracing", "tracing-otlp", "tracing-prometheus"] }
-
-# P2P dependency
-gate-p2p = { path = "../p2p" }
-
-# Utilities
-hex = { workspace = true }
-http = { workspace = true }
-http-body-util = { version = "0.1", optional = true }
-hyper = { workspace = true }
-hyper-util = { version = "0.1", features = ["server", "client", "tokio"], optional = true }
-
-# Let's Encrypt support
-instant-acme = { version = "0.8", default-features = false, optional = true }
-
-# P2P networking
-iroh = { workspace = true }
-
-# Utilities
-n0-future = "0.3"
-
-# Certificate generation
-rcgen = { version = "0.14", optional = true }
-
-# Serialization
-serde = { workspace = true }
-serde_json = { workspace = true }
-thiserror = { workspace = true }
-
-# DNS resolution
-trust-dns-resolver = { version = "0.23", optional = true }
-
-# Async runtime
-tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
-tokio-rustls = { version = "0.26", default-features = false, optional = true }
-tower = { version = "0.5", optional = true }
-tracing = { workspace = true }
-tracing-subscriber = { workspace = true, optional = true }
-uuid = { version = "1", features = ["v4"], optional = true }
-x509-parser = { version = "0.18", optional = true }
-
-[dev-dependencies]
-gate-daemon = { path = "../daemon" }
-gate-p2p = { path = "../p2p" }
-gate-tlsforward = { path = ".", features = ["server"] }
-rand = { workspace = true }
-tempfile = "3"
-tokio-test = "0.4"
-tracing-subscriber = { workspace = true }
diff --git a/crates/tlsforward/README.md b/crates/tlsforward/README.md
deleted file mode 100644
index 62af6708..00000000
--- a/crates/tlsforward/README.md
+++ /dev/null
@@ -1,107 +0,0 @@
-# gate-tlsforward
-
-TLS forwarding service that enables public web access to P2P Gate nodes. Provides both server (standalone TLS forward) and client (node integration) functionality.
-
-## Responsibilities
-
-- **TLS Forwarding**: Proxy HTTPS traffic to P2P nodes without terminating TLS
-- **DNS Management**: Automated DNS records via Cloudflare API
-- **Certificate Support**: Let's Encrypt integration for public domains
-- **SNI Routing**: Routes requests based on TLS Server Name Indication
-- **Rate Limiting**: Protects relay from abuse
-
-## Binary
-
-```bash
-gate-tlsforward serve # Run standalone TLS forward server
-```
-
-## Organization
-
-```
-src/
-├── client/          # Client library for nodes
-│   ├── cert.rs     # Certificate management
-│   ├── tlsforward.rs    # TLS forward registration
-│   └── handler.rs  # TLS forwarding handler
-├── server/          # TLS forward server implementation
-│   ├── proxy.rs    # HTTPS proxy logic
-│   ├── dns.rs      # Cloudflare DNS management
-│   └── state.rs    # Connection tracking
-└── common/          # Shared protocol definitions
-```
-
-## Features
-
-- `default`: Both client and server
-- `client`: Node-side relay integration only
-- `server`: Standalone TLS forward server only
-
-## Architecture
-
-### How It Works
-
-1. **Node Registration**:
-   - Node connects to TLS forward server via P2P
-   - Requests DNS challenge for Let's Encrypt
-   - Obtains certificate for `{node-id}.private.hellas.ai`
-   - Registers domain with TLS forward server
-
-2. **HTTPS Routing**:
-   - Browser connects to `https://{node-id}.private.hellas.ai`
-   - TLS forward server extracts node ID from SNI
-   - Opens TLS forwarding stream to node via P2P
-   - Node terminates TLS with its certificate
-   - TLS forward server proxies encrypted bytes bidirectionally
-
-3. **Security Model**:
-   - Private keys never leave nodes
-   - TLS forward server only sees encrypted traffic
-   - Nodes control their own certificates
-
-## Client Usage
-
-```rust
-use gate_tlsforward::{TlsForwardClient, CertificateManager};
-
-let cert_manager = CertificateManager::new(state_dir);
-let tls_forward_client = TlsForwardClient::new(endpoint, cert_manager);
-
-// Register with TLS forward server
-tls_forward_client.register().await?;
-```
-
-## Server Configuration
-
-```toml
-[tlsforward]
-bind = "0.0.0.0:443"
-domain = "private.hellas.ai"
-
-[cloudflare]
-api_token = "xxx"
-zone_id = "yyy"
-```
-
-## Dependencies
-
-Client:
-- `instant-acme`: Let's Encrypt client
-- `rcgen`: Self-signed certificate generation
-- `gate-p2p`: P2P connectivity
-
-Server adds:
-- `cloudflare`: DNS API client
-- `axum`: HTTP server
-- `x509-parser`: Certificate validation
-
-## Protocols
-
-- **TLS Forward**: `/gate.tlsforward.v1.TlsForward/1.0`
-- **HTTP API**: `/gate.tlsforward.v1.Http/1.0`
-
-## Risks
-
-- **DNS Propagation**: Certificate issuance depends on DNS updates
-- **Rate Limits**: Let's Encrypt and Cloudflare API limits
-- **Single Point**: TLS forward server is centralized (mitigated by self-hosting)
\ No newline at end of file
diff --git a/crates/tlsforward/src/bin/gate-tlsforward.rs b/crates/tlsforward/src/bin/gate-tlsforward.rs
deleted file mode 100644
index b196eeb5..00000000
--- a/crates/tlsforward/src/bin/gate-tlsforward.rs
+++ /dev/null
@@ -1,272 +0,0 @@
-//! Gate TLS forward server binary
-#[macro_use]
-extern crate tracing;
-
-use anyhow::Result;
-use axum::{Router as AxumRouter, routing::get};
-use clap::Parser;
-use futures::stream::StreamExt;
-use gate_core::tracing::{
-    config::{InstrumentationConfig, OtlpConfig},
-    init::init_tracing,
-    metrics::{self, gauge},
-    prometheus::export_prometheus,
-};
-use gate_tlsforward::server::{
-    config::TlsForwardConfig,
-    dns_challenge::DnsChallengeManager,
-    http_handler::TlsForwardHttpHandler,
-    https_proxy::{HttpsProxy, HttpsProxyConfig},
-    registry::ProxyRegistry,
-    state_dir::TlsForwardStateDir,
-};
-use iroh::{Endpoint, Watcher, protocol::Router};
-use std::sync::Arc;
-
-/// Gate TLS forward server - P2P TLS forwarding for secure HTTPS tunneling
-#[derive(Parser, Debug)]
-#[command(author, version, about, long_about = None)]
-struct Cli {
-    /// Configuration file path
-    #[arg(short = 'c', long = "config")]
-    config: Option<String>,
-}
-
-#[tokio::main]
-async fn main() -> Result<()> {
-    // Parse command line arguments
-    let cli = Cli::parse();
-
-    // Load initial configuration
-    let config = if let Some(config_path) = &cli.config {
-        info!("Loading configuration from: {}", config_path);
-        TlsForwardConfig::load_from_file(config_path)?
-    } else {
-        TlsForwardConfig::load()?
-    };
-
-    // Initialize instrumentation
-    let instrumentation_config = InstrumentationConfig {
-        service_name: "gate-tlsforward".to_string(),
-        service_version: env!("CARGO_PKG_VERSION").to_string(),
-        log_level: std::env::var("RUST_LOG").unwrap_or_else(|_| config.server.log_level.clone()),
-        otlp: std::env::var("OTLP_ENDPOINT")
-            .ok()
-            .map(|endpoint| OtlpConfig {
-                endpoint,
-                headers: None,
-            }),
-    };
-    init_tracing(&instrumentation_config)?;
-
-    info!(
-        "Starting Gate TLS Forward Server with configuration: {:#?}",
-        config
-    );
-
-    // Create state directory manager
-    let state_dir = TlsForwardStateDir::new();
-    state_dir.create_directories().await?;
-
-    // Load or generate secret key
-    let secret_key_path = config
-        .p2p
-        .secret_key_path
-        .clone()
-        .or_else(|| Some(state_dir.secret_key_path().to_string_lossy().into_owned()));
-
-    let secret_key = if let Some(path) = &secret_key_path {
-        match tokio::fs::read_to_string(path).await {
-            Ok(contents) => {
-                let hex_key = contents.trim();
-                match hex::decode(hex_key) {
-                    Ok(bytes) if bytes.len() == 32 => {
-                        let mut key_bytes = [0u8; 32];
-                        key_bytes.copy_from_slice(&bytes);
-                        info!("Loaded secret key from {}", path);
-                        Some(iroh::SecretKey::from_bytes(&key_bytes))
-                    }
-                    _ => {
-                        error!("Invalid secret key format in {}, generating new key", path);
-                        None
-                    }
-                }
-            }
-            Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
-                info!("Secret key file not found at {}, will create new key", path);
-                None
-            }
-            Err(e) => {
-                error!("Failed to read secret key from {}: {}", path, e);
-                return Err(e.into());
-            }
-        }
-    } else {
-        None
-    };
-
-    // Create P2P endpoint
-    let mut builder = Endpoint::builder();
-
-    if let Some(secret_key) = secret_key.clone() {
-        builder = builder.secret_key(secret_key);
-    }
-
-    for bind_addr in config.p2p.bind_addrs.iter() {
-        info!("Setting P2P bind address: {}", bind_addr);
-        match bind_addr {
-            std::net::SocketAddr::V4(addr) => {
-                builder = builder.bind_addr_v4(*addr);
-            }
-            std::net::SocketAddr::V6(addr) => {
-                builder = builder.bind_addr_v6(*addr);
-            }
-        }
-    }
-
-    if config.p2p.enable_discovery {
-        builder = builder.discovery_n0();
-    }
-
-    // Add ALPN protocols
-    builder = builder.alpns(vec![gate_tlsforward::TLSFORWARD_HTTP_ALPN.to_vec()]);
-
-    let endpoint = builder.bind().await?;
-    let node_id = endpoint.node_id();
-
-    // Save the secret key if we have a path and didn't load one
-    if let (Some(path), None) = (&secret_key_path, &secret_key) {
-        let key_bytes = endpoint.secret_key().to_bytes();
-        let hex_key = hex::encode(key_bytes);
-
-        // Create parent directory if it doesn't exist
-        if let Some(parent) = std::path::Path::new(path).parent() {
-            tokio::fs::create_dir_all(parent).await?;
-        }
-
-        tokio::fs::write(path, hex_key).await?;
-        info!("Saved new secret key to {}", path);
-    }
-
-    info!("P2P endpoint started, waiting to get node address...");
-    let node_addrs = loop {
-        if let Some(node_addr) = endpoint.node_addr().stream().next().await {
-            if let Some(addr) = node_addr {
-                info!("Node address obtained: {:?}", addr);
-                break addr;
-            } else {
-                info!("Waiting for node address...");
-            }
-        }
-    };
-
-    info!("Node ID: {}", node_id);
-    info!("Node address: {:?}", node_addrs);
-
-    // Initialize tlsforward metrics
-    gauge("tlsforward_info").set(1);
-    gauge("tlsforward_https_connections_active").set(0);
-    gauge("tlsforward_http_requests_active").set(0);
-    gauge("tlsforward_registry_nodes").set(0);
-
-    // Create registry
-    let registry = ProxyRegistry::new(config.https_proxy.domain_suffix.clone());
-    let registry_arc = Arc::new(registry.clone());
-
-    // Create DNS challenge manager for ACME if Cloudflare is configured
-    let dns_challenge_manager = if let (Some(api_token), Some(zone_id)) = (
-        &config.dns.cloudflare.api_token,
-        &config.dns.cloudflare.zone_id,
-    ) {
-        match DnsChallengeManager::new(
-            api_token.clone(),
-            zone_id.clone(),
-            config.https_proxy.domain_suffix.clone(),
-        ) {
-            Ok(manager) => Arc::new(manager),
-            Err(e) => {
-                error!("Failed to create DNS challenge manager: {}", e);
-                return Err(e);
-            }
-        }
-    } else {
-        error!("DNS challenge manager requires Cloudflare configuration");
-        return Err(anyhow::anyhow!(
-            "Missing Cloudflare configuration for DNS challenges"
-        ));
-    };
-
-    // Build the router with protocol handlers
-    let router = Router::builder(endpoint.clone())
-        // HTTP handler (serves REST APIs for ACME and tlsforward control)
-        .accept(
-            gate_tlsforward::TLSFORWARD_HTTP_ALPN,
-            TlsForwardHttpHandler::new(
-                dns_challenge_manager,
-                registry_arc.clone(),
-                config.https_proxy.domain_suffix.clone(),
-                node_id,
-                // node_addrs.clone(),
-            ),
-        )
-        .spawn();
-
-    info!("P2P router started and accepting connections");
-
-    // Create and start HTTPS proxy
-    let https_config = HttpsProxyConfig {
-        bind_addr: config.https_proxy.bind_addr,
-        timeouts: Default::default(),
-        max_connections: config.https_proxy.max_connections,
-        buffer_size: 16 * 1024,
-    };
-
-    let https_proxy = Arc::new(HttpsProxy::new(https_config, registry, endpoint.clone()));
-
-    // Start HTTPS proxy in background
-    let proxy_handle = tokio::spawn(async move {
-        if let Err(e) = https_proxy.start().await {
-            error!("HTTPS proxy error: {}", e);
-        }
-    });
-
-    info!("HTTPS proxy listening on {}", config.https_proxy.bind_addr);
-
-    // Start metrics server if configured
-    let metrics_handle = if let Some(metrics_addr) = config.server.metrics_addr {
-        info!("Starting metrics server on {}", metrics_addr);
-
-        let metrics_router = AxumRouter::new().route(
-            "/metrics",
-            get(|| async { export_prometheus(metrics::global()) }),
-        );
-
-        let listener = tokio::net::TcpListener::bind(metrics_addr).await?;
-        info!(
-            "Prometheus metrics endpoint available at http://{}/metrics",
-            metrics_addr
-        );
-
-        Some(tokio::spawn(async move {
-            if let Err(e) = axum::serve(listener, metrics_router).await {
-                error!("Metrics server error: {}", e);
-            }
-        }))
-    } else {
-        info!("Metrics server not configured (set server.metrics_addr to enable)");
-        None
-    };
-
-    // Wait for shutdown signal
-    tokio::signal::ctrl_c().await?;
-    info!("Shutting down...");
-
-    // Graceful shutdown
-    proxy_handle.abort();
-    if let Some(handle) = metrics_handle {
-        handle.abort();
-    }
-    router.shutdown().await?;
-
-    Ok(())
-}
diff --git a/crates/tlsforward/src/client/certificate_manager.rs b/crates/tlsforward/src/client/certificate_manager.rs
deleted file mode 100644
index 162b6012..00000000
--- a/crates/tlsforward/src/client/certificate_manager.rs
+++ /dev/null
@@ -1,411 +0,0 @@
-//! Certificate management for Let's Encrypt integration
-use crate::common::ChallengeStatus;
-use anyhow::{Context, Result};
-use std::path::PathBuf;
-use std::sync::Arc;
-use std::time::Duration;
-use tokio::sync::RwLock;
-
-use instant_acme::{
-    Account, AccountCredentials, ChallengeType, Identifier, LetsEncrypt, NewAccount, NewOrder,
-    OrderStatus,
-};
-
-/// Certificate manager for handling Let's Encrypt certificates
-pub struct CertificateManager {
-    /// Path to store certificates
-    cert_path: PathBuf,
-    /// Path to store account credentials
-    account_path: PathBuf,
-    /// TLS forward client for DNS challenges
-    tls_forward_client: Option<super::TlsForwardClient>,
-    /// Cached account
-    account: RwLock<Option<Arc<Account>>>,
-}
-
-impl CertificateManager {
-    /// Create a new certificate manager
-    pub fn new(data_dir: PathBuf) -> Self {
-        let cert_path = data_dir.join("certificates");
-        let account_path = data_dir.join("acme");
-
-        // Ensure directories exist
-        std::fs::create_dir_all(&cert_path).ok();
-        std::fs::create_dir_all(&account_path).ok();
-
-        Self {
-            cert_path,
-            account_path,
-            tls_forward_client: None,
-            account: RwLock::new(None),
-        }
-    }
-
-    /// Set the TLS forward client for DNS challenges
-    pub fn set_tls_forward_client(&mut self, client: super::TlsForwardClient) {
-        self.tls_forward_client = Some(client);
-    }
-
-    /// Get or create ACME account
-    async fn get_or_create_account(&self, email: &str) -> Result<Arc<Account>> {
-        // Check if we have a cached account
-        {
-            let account_lock = self.account.read().await;
-            if let Some(account) = account_lock.as_ref() {
-                return Ok(account.clone());
-            }
-        }
-
-        // Try to load from disk
-        let creds_path = self.account_path.join("account.json");
-        let account = if creds_path.exists() {
-            debug!("Loading ACME account from disk");
-            let creds_json = tokio::fs::read_to_string(&creds_path).await?;
-            let creds: AccountCredentials = serde_json::from_str(&creds_json)?;
-            Account::builder()?.from_credentials(creds).await?
-        } else {
-            info!("Creating new ACME account for {}", email);
-            let contacts = [format!("mailto:{email}")];
-            let (account, creds) = Account::builder()?
-                .create(
-                    &NewAccount {
-                        contact: &contacts.iter().map(|s| s.as_str()).collect::<Vec<_>>(),
-                        terms_of_service_agreed: true,
-                        only_return_existing: false,
-                    },
-                    LetsEncrypt::Production.url().to_string(),
-                    None,
-                )
-                .await?;
-
-            // Save credentials
-            let creds_json = serde_json::to_string_pretty(&creds)?;
-            tokio::fs::write(&creds_path, creds_json).await?;
-
-            account
-        };
-
-        let account = Arc::new(account);
-
-        // Cache the account
-        {
-            let mut account_lock = self.account.write().await;
-            *account_lock = Some(account.clone());
-        }
-
-        Ok(account)
-    }
-
-    /// Request a certificate for a domain
-    pub async fn request_certificate(&self, domain: &str, email: &str) -> Result<()> {
-        let tls_forward_client = self
-            .tls_forward_client
-            .as_ref()
-            .context("TLS forward client not configured")?;
-
-        info!("Requesting certificate for domain: {}", domain);
-
-        // Get or create account
-        let account = self.get_or_create_account(email).await?;
-
-        // Create order
-        let identifier = Identifier::Dns(domain.to_string());
-        debug!("Creating ACME order for identifier: {:?}", identifier);
-        let mut order = account.new_order(&NewOrder::new(&[identifier])).await?;
-        debug!("Order created: {:?}", order.state());
-
-        // Get authorizations
-        let mut authorizations = order.authorizations();
-
-        let mut authz = authorizations
-            .next()
-            .await
-            .ok_or_else(|| anyhow::anyhow!("No authorizations found"))??;
-
-        let mut challenge = authz
-            .challenge(ChallengeType::Dns01)
-            .ok_or_else(|| anyhow::anyhow!("No DNS-01 challenge found"))?;
-
-        let dns_value = challenge.key_authorization().dns_value();
-
-        info!("Creating DNS challenge for domain: {}", domain);
-        info!("DNS challenge value: {}", dns_value);
-
-        // Create DNS challenge through TLS forward server
-        let challenge_response = tls_forward_client
-            .create_challenge(domain.to_string(), "_acme-challenge".to_string(), dns_value)
-            .await
-            .context("Failed to create challenge with TLS forward server")?;
-
-        info!("Challenge response: {:?}", challenge_response);
-
-        // Validate that we got a valid challenge ID
-        if challenge_response.id.is_empty() {
-            return Err(anyhow::anyhow!(
-                "Received empty challenge ID from TLS forward server"
-            ));
-        }
-
-        // Check if the challenge was created successfully
-        if let ChallengeStatus::Failed { error } = &challenge_response.status {
-            return Err(anyhow::anyhow!("Challenge creation failed: {}", error));
-        }
-
-        // Wait for DNS propagation
-        info!(
-            "Waiting for DNS propagation for challenge ID: {}",
-            challenge_response.id
-        );
-        tls_forward_client
-            .wait_for_dns_propagation(
-                &challenge_response.id,
-                Duration::from_secs(300), // 5 minute timeout
-                Duration::from_secs(5),   // 5 second check interval
-            )
-            .await
-            .inspect_err(|_e| {
-                // Try to clean up the challenge on error
-                let challenge_id = challenge_response.id.clone();
-                let tls_forward_client = tls_forward_client.clone();
-                tokio::spawn(async move {
-                    if let Err(cleanup_err) =
-                        tls_forward_client.delete_challenge(&challenge_id).await
-                    {
-                        warn!(
-                            "Failed to clean up challenge {} after error: {}",
-                            challenge_id, cleanup_err
-                        );
-                    }
-                });
-            })?;
-
-        // Notify ACME server that challenge is ready
-        info!("Notifying ACME server that challenge is ready");
-        challenge.set_ready().await?;
-
-        // Wait for challenge validation
-        let mut attempts = 0;
-        let max_attempts = 30;
-
-        loop {
-            tokio::time::sleep(std::time::Duration::from_secs(2)).await;
-
-            order.refresh().await?;
-            match order.state().status {
-                OrderStatus::Ready => {
-                    info!("Order is ready for finalization");
-                    break;
-                }
-                OrderStatus::Invalid => {
-                    error!("Order validation failed. Order state: {:?}", order.state());
-                    // Try to get more details about the failure
-                    let mut authz_iter = order.authorizations();
-                    let mut idx = 0;
-                    while let Some(Ok(authz)) = authz_iter.next().await {
-                        error!("Authorization {}: status={:?}", idx, authz.status);
-                        for chall in &authz.challenges {
-                            error!(
-                                "  Challenge type={:?} status={:?} error={:?}",
-                                chall.r#type, chall.status, chall.error
-                            );
-                        }
-                        idx += 1;
-                    }
-                    // Clean up DNS record
-                    tls_forward_client
-                        .delete_challenge(&challenge_response.id)
-                        .await
-                        .ok();
-                    return Err(anyhow::anyhow!("Order validation failed"));
-                }
-                OrderStatus::Valid => {
-                    info!("Order already valid");
-                    break;
-                }
-                _ => {
-                    debug!("Order status: {:?}", order.state().status);
-                }
-            }
-
-            attempts += 1;
-            if attempts >= max_attempts {
-                // Clean up DNS record
-                tls_forward_client
-                    .delete_challenge(&challenge_response.id)
-                    .await
-                    .ok();
-                return Err(anyhow::anyhow!("Challenge validation timeout"));
-            }
-        }
-
-        // Clean up DNS record
-        info!("Cleaning up DNS challenge");
-        tls_forward_client
-            .delete_challenge(&challenge_response.id)
-            .await?;
-
-        // Finalize order - instant-acme generates the key for us
-        let private_key_pem = order.finalize().await?;
-
-        // Wait for certificate
-        let cert_chain_pem = loop {
-            match order.certificate().await? {
-                Some(cert_chain_pem) => break cert_chain_pem,
-                None => tokio::time::sleep(std::time::Duration::from_secs(1)).await,
-            }
-        };
-
-        // Save certificate and key
-        let cert_dir = self.cert_path.join(domain);
-        tokio::fs::create_dir_all(&cert_dir).await?;
-
-        let cert_path = cert_dir.join("fullchain.pem");
-        let key_path = cert_dir.join("key.pem");
-
-        // Save full chain (cert + intermediates)
-        tokio::fs::write(&cert_path, &cert_chain_pem).await?;
-
-        // Save private key
-        tokio::fs::write(&key_path, &private_key_pem).await?;
-
-        info!("Certificate saved to {}", cert_dir.display());
-        Ok(())
-    }
-
-    /// Check if a certificate exists for a domain
-    pub async fn has_certificate(&self, domain: &str) -> bool {
-        let cert_path = self.cert_path.join(domain).join("fullchain.pem");
-        cert_path.exists()
-    }
-
-    /// Get certificate paths for a domain
-    pub fn get_certificate_paths(&self, domain: &str) -> Option<CertificatePaths> {
-        let cert_dir = self.cert_path.join(domain);
-        let cert_path = cert_dir.join("fullchain.pem");
-        let key_path = cert_dir.join("key.pem");
-
-        if cert_path.exists() && key_path.exists() {
-            Some(CertificatePaths {
-                cert: cert_path,
-                key: key_path,
-                chain: None, // fullchain.pem already includes the chain
-            })
-        } else {
-            None
-        }
-    }
-
-    /// Create a TLS acceptor from available certificates or generate self-signed
-    pub async fn get_or_create_tls_acceptor(
-        &self,
-        domains: &[String],
-    ) -> Result<tokio_rustls::TlsAcceptor> {
-        use tokio_rustls::rustls::{
-            ServerConfig,
-            pki_types::{CertificateDer, PrivateKeyDer, pem::PemObject},
-        };
-
-        // Try to find existing certificate for any of the domains
-        for domain in domains {
-            if let Some(paths) = self.get_certificate_paths(domain)
-                && paths.cert.exists()
-                && paths.key.exists()
-            {
-                info!("Using existing certificate for domain: https://{}", domain);
-
-                // Load certificate and key
-                let certs = CertificateDer::pem_file_iter(&paths.cert)
-                    .context("Failed to load certificate")?
-                    .map(|cert| cert.context("Failed to parse certificate"))
-                    .collect::<Result<Vec<_>>>()?;
-
-                let key = PrivateKeyDer::from_pem_file(&paths.key)
-                    .context("Failed to load private key")?;
-
-                // Create server config
-                let config = ServerConfig::builder()
-                    .with_no_client_auth()
-                    .with_single_cert(certs, key)
-                    .context("Failed to create TLS config")?;
-
-                return Ok(tokio_rustls::TlsAcceptor::from(Arc::new(config)));
-            }
-        }
-
-        // No certificate found, generate self-signed
-        warn!(
-            "No certificates found for domains {:?}, generating self-signed certificate",
-            domains
-        );
-        self.generate_self_signed_tls_acceptor(
-            domains.first().map(|s| s.as_str()).unwrap_or("localhost"),
-        )
-    }
-
-    /// Generate a self-signed certificate
-    fn generate_self_signed_tls_acceptor(&self, domain: &str) -> Result<tokio_rustls::TlsAcceptor> {
-        use rcgen::{CertifiedKey, generate_simple_self_signed};
-        use tokio_rustls::rustls::{ServerConfig, pki_types::PrivateKeyDer};
-
-        // Generate self-signed certificate
-        let subject_alt_names = vec![domain.to_string(), "localhost".to_string()];
-        let CertifiedKey { cert, signing_key } = generate_simple_self_signed(subject_alt_names)
-            .context("Failed to generate self-signed certificate")?;
-
-        let cert_der = cert.der().clone();
-        let key_der = PrivateKeyDer::Pkcs8(signing_key.serialize_der().into());
-
-        // Create server config
-        let config = ServerConfig::builder()
-            .with_no_client_auth()
-            .with_single_cert(vec![cert_der], key_der)
-            .context("Failed to create TLS config")?;
-
-        debug!("Generated self-signed certificate for domain: {}", domain);
-        Ok(tokio_rustls::TlsAcceptor::from(Arc::new(config)))
-    }
-}
-
-/// Paths to certificate files
-#[derive(Debug, Clone)]
-pub struct CertificatePaths {
-    pub cert: PathBuf,
-    pub key: PathBuf,
-    pub chain: Option<PathBuf>,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use tempfile::TempDir;
-
-    #[tokio::test]
-    async fn test_certificate_manager_creation() {
-        let temp_dir = TempDir::new().unwrap();
-        let manager = CertificateManager::new(temp_dir.path().to_path_buf());
-
-        assert!(manager.cert_path.exists());
-        assert!(manager.account_path.exists());
-    }
-
-    #[test]
-    fn test_certificate_paths() {
-        let temp_dir = TempDir::new().unwrap();
-        let manager = CertificateManager::new(temp_dir.path().to_path_buf());
-
-        // No certificate should exist
-        assert!(manager.get_certificate_paths("test.example.com").is_none());
-
-        // Create fake certificate files
-        let cert_dir = manager.cert_path.join("test.example.com");
-        std::fs::create_dir_all(&cert_dir).unwrap();
-        std::fs::write(cert_dir.join("fullchain.pem"), "cert").unwrap();
-        std::fs::write(cert_dir.join("key.pem"), "key").unwrap();
-
-        // Now paths should be found
-        let paths = manager.get_certificate_paths("test.example.com").unwrap();
-        assert!(paths.cert.exists());
-        assert!(paths.key.exists());
-        assert!(paths.chain.is_none());
-    }
-}
diff --git a/crates/tlsforward/src/client/mod.rs b/crates/tlsforward/src/client/mod.rs
deleted file mode 100644
index 78b2b6cd..00000000
--- a/crates/tlsforward/src/client/mod.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//! TLS forward client functionality for daemons
-
-mod certificate_manager;
-mod tls_forward_client;
-mod tls_forward_handler;
-
-pub use certificate_manager::CertificateManager;
-pub use tls_forward_client::TlsForwardClient;
-pub use tls_forward_handler::{TlsAcceptorProvider, TlsForwardHandler};
diff --git a/crates/tlsforward/src/client/tls_forward_client.rs b/crates/tlsforward/src/client/tls_forward_client.rs
deleted file mode 100644
index 568040be..00000000
--- a/crates/tlsforward/src/client/tls_forward_client.rs
+++ /dev/null
@@ -1,311 +0,0 @@
-//! TLS forward client for daemon-tlsforward communication
-
-use crate::TLSFORWARD_HTTP_ALPN;
-use crate::common::{
-    error::{Result, TlsForwardError},
-    types::TlsForwardInfo,
-    *,
-};
-use bytes::Bytes;
-use futures::future::{AbortHandle, Abortable};
-use gate_p2p::stream::CombinedStream;
-use http_body_util::{BodyExt, Full};
-use hyper::Method;
-use hyper_util::rt::TokioIo;
-use iroh::{Endpoint, NodeId};
-use std::sync::Arc;
-use std::time::Duration;
-
-/// Client for all daemon-tlsforward communications
-#[derive(Clone)]
-pub struct TlsForwardClient {
-    endpoint: Arc<Endpoint>,
-    forwarder: NodeId,
-}
-
-impl TlsForwardClient {
-    /// Create a new TLS forward client
-    pub fn new(endpoint: Arc<Endpoint>, forwarder: NodeId) -> Self {
-        Self {
-            endpoint,
-            forwarder,
-        }
-    }
-
-    /// Register with the TLS forward service
-    pub async fn register(&self) -> Result<(String, TlsForwardInfo)> {
-        info!("Registering with TLS forward server at {}", self.forwarder);
-
-        let request = RegistrationRequest {};
-        let response: RegistrationResponse = self
-            .request(Method::POST, "/register", Some(&request))
-            .await?;
-
-        debug!("TLS forward info: {:?}", response);
-
-        Ok((response.domain, response.tlsforward_info))
-    }
-
-    /// Unregister from TLS forward service
-    pub async fn unregister(&self) -> Result<()> {
-        info!("Unregistering from TLS forward at {}", self.forwarder);
-
-        self.request::<(), EmptyResponse>(Method::DELETE, "/unregister", None)
-            .await?;
-
-        info!("Successfully unregistered");
-        Ok(())
-    }
-
-    /// Check registration status
-    pub async fn status(&self) -> Result<StatusResponse> {
-        debug!("Checking status with TLS forward");
-        self.request(Method::GET, "/status", None::<&()>).await
-    }
-
-    /// Ping TLS forward service
-    pub async fn ping(&self) -> Result<Duration> {
-        let start = std::time::Instant::now();
-
-        self.request::<(), EmptyResponse>(Method::POST, "/ping", None)
-            .await?;
-
-        let latency = start.elapsed();
-        debug!("TLS forward ping latency: {:?}", latency);
-        Ok(latency)
-    }
-
-    /// Create a DNS challenge
-    pub async fn create_challenge(
-        &self,
-        domain: String,
-        challenge: String,
-        value: String,
-    ) -> Result<CreateChallengeResponse> {
-        let request = CreateChallengeRequest {
-            domain,
-            challenge,
-            value,
-        };
-
-        let response = self
-            .request(Method::POST, "/acme/challenge", Some(&request))
-            .await?;
-
-        info!("Created DNS challenge: {:?}", response);
-        Ok(response)
-    }
-
-    /// Get challenge status
-    pub async fn get_challenge_status(&self, id: &str) -> Result<ChallengeStatusResponse> {
-        if id.is_empty() {
-            return Err(TlsForwardError::Protocol(
-                "Cannot get status for empty challenge ID".to_string(),
-            ));
-        }
-
-        self.request(
-            Method::GET,
-            &format!("/acme/challenge/{id}/status"),
-            None::<&()>,
-        )
-        .await
-    }
-
-    /// Delete a challenge
-    pub async fn delete_challenge(&self, id: &str) -> Result<DeleteChallengeResponse> {
-        if id.is_empty() {
-            return Err(TlsForwardError::Protocol(
-                "Cannot delete challenge with empty ID".to_string(),
-            ));
-        }
-
-        let response = self
-            .request(
-                Method::DELETE,
-                &format!("/acme/challenge/{id}"),
-                None::<&()>,
-            )
-            .await?;
-
-        info!("Deleted DNS challenge: {}", id);
-        Ok(response)
-    }
-
-    /// Wait for DNS propagation
-    pub async fn wait_for_dns_propagation(
-        &self,
-        id: &str,
-        timeout: Duration,
-        check_interval: Duration,
-    ) -> Result<()> {
-        // Validate challenge ID
-        if id.is_empty() {
-            return Err(TlsForwardError::Protocol(
-                "Cannot wait for propagation with empty challenge ID".to_string(),
-            ));
-        }
-
-        let start = std::time::Instant::now();
-
-        loop {
-            let status = self.get_challenge_status(id).await?;
-
-            match &status.status {
-                ChallengeStatus::Propagated => {
-                    info!("DNS challenge {} is ready after {:?}", id, start.elapsed());
-                    return Ok(());
-                }
-                ChallengeStatus::Pending => {
-                    debug!(
-                        "DNS challenge {} still pending (checks: {})",
-                        id, status.checks
-                    );
-                }
-                ChallengeStatus::Failed { error } => {
-                    return Err(TlsForwardError::Protocol(format!(
-                        "DNS challenge {id} failed: {error}"
-                    )));
-                }
-            }
-
-            if start.elapsed() > timeout {
-                return Err(TlsForwardError::Protocol(format!(
-                    "DNS propagation timeout after {timeout:?}"
-                )));
-            }
-
-            tokio::time::sleep(check_interval).await;
-        }
-    }
-
-    /// Make a typed HTTP request to the TLS forward server
-    async fn request<Req, Res>(&self, method: Method, path: &str, body: Option<&Req>) -> Result<Res>
-    where
-        Req: serde::Serialize,
-        Res: for<'de> serde::Deserialize<'de>,
-    {
-        // Create new connection to TLS forward server
-        debug!("Creating new connection to TLS forward server");
-        let connection = self
-            .endpoint
-            .connect(self.forwarder, TLSFORWARD_HTTP_ALPN)
-            .await
-            .map_err(TlsForwardError::P2pConnect)?;
-
-        debug!("Connected, opening bidirectional stream");
-        // Open bidirectional stream
-        let (send_stream, recv_stream) = connection.open_bi().await?;
-        debug!("Stream opened, creating HTTP connection");
-        let stream = CombinedStream::new(recv_stream, send_stream);
-        let io = TokioIo::new(stream);
-
-        // Create HTTP client connection
-        debug!("Starting HTTP handshake");
-        let (mut sender, conn) = hyper::client::conn::http1::handshake(io)
-            .await
-            .map_err(|e| TlsForwardError::Protocol(format!("HTTP handshake failed: {e}")))?;
-
-        debug!("HTTP handshake complete, spawning connection handler");
-
-        // Create abortable connection handler
-        let (abort_handle, abort_registration) = AbortHandle::new_pair();
-        let conn_future = Abortable::new(conn, abort_registration);
-
-        // Spawn the handler with abort support
-        tokio::spawn(async move {
-            match conn_future.await {
-                Ok(Ok(())) => debug!("HTTP connection handler completed successfully"),
-                Ok(Err(e)) => error!("HTTP connection handler error: {}", e),
-                Err(e) => debug!("HTTP connection handler was aborted: {}", e),
-            }
-        });
-
-        // Store abort handle to ensure cleanup on drop
-        let _abort_handle = abort_handle;
-
-        // Build request body
-        let req_body = if let Some(body) = body {
-            let json = serde_json::to_vec(body)?;
-            Full::new(Bytes::from(json))
-        } else {
-            Full::new(Bytes::new())
-        };
-
-        // Build HTTP request
-        debug!("Building HTTP request: {} {}", method, path);
-        let request = hyper::Request::builder()
-            .method(method)
-            .uri(path)
-            .header("Content-Type", "application/json")
-            .header("Host", "tlsforward.private.internal")
-            .body(req_body)
-            .map_err(|e| TlsForwardError::Protocol(format!("Failed to build request: {e}")))?;
-
-        // Send request
-        debug!("Sending HTTP request");
-        let response = sender
-            .send_request(request)
-            .await
-            .map_err(|e| TlsForwardError::Protocol(format!("Failed to send request: {e}")))?;
-
-        debug!("Got response with status: {}", response.status());
-
-        // Check status
-        let status = response.status();
-        if !status.is_success() {
-            let body = response
-                .into_body()
-                .collect()
-                .await
-                .map(|b| b.to_bytes())
-                .unwrap_or_default();
-            let error_text = String::from_utf8_lossy(&body);
-            return Err(TlsForwardError::Protocol(format!(
-                "HTTP {} {}: {}",
-                status.as_u16(),
-                status.canonical_reason().unwrap_or("Unknown"),
-                error_text
-            )));
-        }
-
-        // Read and parse response
-        let body_bytes = response
-            .into_body()
-            .collect()
-            .await
-            .map_err(|e| TlsForwardError::Protocol(format!("Failed to read response: {e}")))?
-            .to_bytes();
-
-        // Connection will be closed when it goes out of scope
-
-        if body_bytes.is_empty() {
-            // Try to parse as unit type or empty object
-            serde_json::from_str("{}").map_err(|e| {
-                TlsForwardError::Protocol(format!("Failed to parse empty response: {e}"))
-            })
-        } else {
-            serde_json::from_slice(&body_bytes)
-                .map_err(|e| TlsForwardError::Protocol(format!("Failed to parse response: {e}")))
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_create_challenge_request_serialization() {
-        let request = CreateChallengeRequest {
-            domain: "test.private.hellas.ai".to_string(),
-            challenge: "_acme-challenge".to_string(),
-            value: "test-value-123".to_string(),
-        };
-
-        let json = serde_json::to_string(&request).unwrap();
-        assert!(json.contains("test.private.hellas.ai"));
-        assert!(json.contains("_acme-challenge"));
-        assert!(json.contains("test-value-123"));
-    }
-}
diff --git a/crates/tlsforward/src/client/tls_forward_handler.rs b/crates/tlsforward/src/client/tls_forward_handler.rs
deleted file mode 100644
index 2bf4805e..00000000
--- a/crates/tlsforward/src/client/tls_forward_handler.rs
+++ /dev/null
@@ -1,238 +0,0 @@
-//! TLS forwarding handler for receiving traffic from relay
-use gate_core::tracing::metrics::{counter, gauge, histogram};
-use gate_http::server::HttpServer;
-use gate_p2p::stream::CombinedStream;
-use iroh::{
-    endpoint::{Connection, RecvStream, SendStream},
-    protocol::{AcceptError, ProtocolHandler},
-};
-use std::future::Future;
-use std::pin::Pin;
-use std::sync::Arc;
-use std::time::{Duration, Instant};
-use tokio::sync::Semaphore;
-use tokio::task::JoinSet;
-use tokio::time::timeout;
-use tokio_rustls::TlsAcceptor;
-
-/// Trait for providing TLS acceptors
-pub trait TlsAcceptorProvider: Send + Sync + Clone + 'static {
-    /// Get the current TLS acceptor
-    fn get_acceptor(&self) -> Pin<Box<dyn Future<Output = TlsAcceptor> + Send + '_>>;
-}
-
-/// Simple static TLS acceptor provider
-impl TlsAcceptorProvider for TlsAcceptor {
-    fn get_acceptor(&self) -> Pin<Box<dyn Future<Output = TlsAcceptor> + Send + '_>> {
-        Box::pin(async { self.clone() })
-    }
-}
-
-/// TLS forwarding handler that receives traffic from relay
-#[derive(Clone)]
-pub struct TlsForwardHandler<P> {
-    tls_acceptor_provider: Arc<P>,
-    http_server: Arc<HttpServer>,
-    connection_timeout: Duration,
-    connections_semaphore: Arc<Semaphore>,
-    max_connections: usize,
-}
-
-impl<P: TlsAcceptorProvider> TlsForwardHandler<P> {
-    /// Create a new TLS forwarding handler
-    pub fn new(
-        tls_acceptor_provider: P,
-        http_server: Arc<HttpServer>,
-        max_connections: usize,
-        connection_timeout_secs: u64,
-    ) -> Self {
-        Self {
-            tls_acceptor_provider: Arc::new(tls_acceptor_provider),
-            http_server,
-            connection_timeout: Duration::from_secs(connection_timeout_secs),
-            connections_semaphore: Arc::new(Semaphore::new(max_connections)),
-            max_connections,
-        }
-    }
-
-    /// Handle a forwarded TLS connection
-    #[instrument(
-        name = "p2p.tls_connection",
-        skip_all,
-        fields(
-            node_id = %node_id,
-            correlation_id = tracing::field::Empty,
-            connection_duration = tracing::field::Empty
-        )
-    )]
-    async fn handle_connection(
-        &self,
-        send: SendStream,
-        recv: RecvStream,
-        node_id: iroh::NodeId,
-    ) -> anyhow::Result<()> {
-        // Try to acquire permit with warning if at capacity
-        let _permit = match self.connections_semaphore.try_acquire() {
-            Ok(permit) => permit,
-            Err(_) => {
-                warn!(
-                    "Connection limit reached ({}/{}), waiting for available slot",
-                    self.max_connections, self.max_connections
-                );
-                counter("relay_connections_rejected").increment();
-                self.connections_semaphore
-                    .acquire()
-                    .await
-                    .map_err(|e| anyhow::anyhow!("Failed to acquire connection permit: {}", e))?
-            }
-        };
-
-        // Track connection metrics
-        let start = Instant::now();
-        gauge("relay_connections_active").increment();
-        counter("relay_connections_total").increment();
-
-        debug!(
-            "Handling TLS forward connection from relay (node: {})",
-            node_id
-        );
-        let active_connections =
-            self.max_connections - self.connections_semaphore.available_permits();
-        debug!(
-            "Active connections: {}/{}",
-            active_connections, self.max_connections
-        );
-
-        // Combine streams
-        let stream = CombinedStream::new(recv, send);
-
-        // Get current TLS acceptor
-        let tls_acceptor = self.tls_acceptor_provider.get_acceptor().await;
-
-        // Terminate TLS
-        let tls_stream = timeout(self.connection_timeout, tls_acceptor.accept(stream))
-            .await
-            .map_err(|_| anyhow::anyhow!("TLS handshake timeout"))?
-            .map_err(|e| anyhow::anyhow!("TLS handshake failed: {}", e))?;
-
-        debug!("TLS handshake completed successfully");
-
-        // Forward to HTTP server with P2P info with a timeout to prevent hanging
-        let http_timeout = Duration::from_secs(300); // 5 minutes for HTTP handling
-        let result = timeout(
-            http_timeout,
-            self.http_server
-                .handle_p2p_stream(tls_stream, node_id, None),
-        )
-        .await
-        .map_err(|_| {
-            error!("HTTP handler timeout after {:?}", http_timeout);
-            anyhow::anyhow!("HTTP handler timeout")
-        })
-        .and_then(|r| r);
-
-        // Record connection duration in span
-        let span = tracing::Span::current();
-        span.record("connection_duration", format!("{:?}", start.elapsed()));
-
-        // Record connection metrics
-        gauge("relay_connections_active").decrement();
-        let duration = start.elapsed();
-        histogram("relay_connection_duration_seconds").observe(duration.as_secs_f64());
-
-        match &result {
-            Ok(_) => {
-                counter("relay_connections_completed_success").increment();
-            }
-            Err(e) => {
-                counter("relay_connections_completed_error").increment();
-                error!("Connection error: {}", e);
-            }
-        }
-
-        result
-    }
-}
-
-impl<P: TlsAcceptorProvider> std::fmt::Debug for TlsForwardHandler<P> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("TlsForwardHandler").finish()
-    }
-}
-
-impl<P: TlsAcceptorProvider> ProtocolHandler for TlsForwardHandler<P> {
-    #[instrument(
-        name = "p2p.accept_connection", 
-        skip_all,
-        fields(
-            remote_node_id = tracing::field::Empty
-        )
-    )]
-    async fn accept(&self, connection: Connection) -> Result<(), AcceptError> {
-        let handler = self.clone();
-        let node_id = connection.remote_node_id()?;
-
-        // Record node ID in span
-        let span = tracing::Span::current();
-        span.record("remote_node_id", node_id.to_string());
-
-        info!("TLS forward handler: Accepted connection from {}", node_id);
-
-        // Track spawned tasks
-        let mut tasks = JoinSet::new();
-
-        // Accept bidirectional streams with timeout
-        loop {
-            match timeout(Duration::from_secs(30), connection.accept_bi()).await {
-                Ok(Ok((send, recv))) => {
-                    let handler = handler.clone();
-                    tasks.spawn(async move {
-                        if let Err(e) = handler.handle_connection(send, recv, node_id).await {
-                            error!("TLS forward connection error: {}", e);
-                        }
-                    });
-
-                    // Clean up completed tasks periodically
-                    while let Some(result) = tasks.try_join_next() {
-                        if let Err(e) = result {
-                            error!("Task join error: {}", e);
-                            counter("relay_connections_task_panicked").increment();
-                        }
-                    }
-                }
-                Ok(Err(e)) => {
-                    // Connection closed
-                    debug!("Connection closed: {}", e);
-                    break;
-                }
-                Err(_) => {
-                    // Timeout - no new streams for 30 seconds
-                    debug!("No new streams for 30 seconds, closing connection");
-                    break;
-                }
-            }
-        }
-
-        // Wait for all spawned tasks to complete
-        let pending_tasks = tasks.len();
-        if pending_tasks > 0 {
-            debug!(
-                "Waiting for {} active stream handlers to complete",
-                pending_tasks
-            );
-            gauge("relay_connections_cleanup_pending").set(pending_tasks as i64);
-
-            while let Some(result) = tasks.join_next().await {
-                if let Err(e) = result {
-                    error!("Task join error during cleanup: {}", e);
-                    counter("relay_connections_task_panicked").increment();
-                }
-            }
-
-            gauge("relay_connections_cleanup_pending").set(0);
-            info!("All stream handlers completed");
-        }
-
-        Ok(())
-    }
-}
diff --git a/crates/tlsforward/src/common/error.rs b/crates/tlsforward/src/common/error.rs
deleted file mode 100644
index 25bec717..00000000
--- a/crates/tlsforward/src/common/error.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-//! Error types for the TLS forward service
-
-use thiserror::Error;
-
-/// Result type alias for TLS forward operations
-pub type Result<T> = std::result::Result<T, TlsForwardError>;
-
-/// Errors that can occur in the TLS forward service
-#[derive(Debug, Error)]
-pub enum TlsForwardError {
-    /// I/O error occurred
-    #[error("I/O error: {0}")]
-    Io(#[from] std::io::Error),
-
-    /// P2P connection error
-    #[error("P2P connection error: {0}")]
-    P2pConnection(#[from] iroh::endpoint::ConnectionError),
-
-    /// P2P connect error
-    #[error("P2P connect error: {0}")]
-    P2pConnect(#[from] iroh::endpoint::ConnectError),
-
-    /// P2P write error
-    #[error("P2P write error: {0}")]
-    P2pWrite(#[from] iroh::endpoint::WriteError),
-
-    /// P2P read error
-    #[error("P2P read error: {0}")]
-    P2pRead(#[from] iroh::endpoint::ReadError),
-
-    /// Invalid SNI or hostname
-    #[error("Invalid SNI: {0}")]
-    InvalidSni(String),
-
-    /// Node not found in registry
-    #[error("Node not found for domain: {0}")]
-    NodeNotFound(String),
-
-    /// TLS/SSL error
-    #[error("TLS error: {0}")]
-    Tls(String),
-
-    /// Timeout occurred
-    #[error("Operation timed out: {0}")]
-    Timeout(String),
-
-    /// HTTP error
-    #[error("HTTP error: {0}")]
-    Http(#[from] http::Error),
-
-    /// Configuration error
-    #[error("Configuration error: {0}")]
-    Config(String),
-
-    /// Registry error
-    #[error("Registry error: {0}")]
-    Registry(String),
-
-    /// Protocol error
-    #[error("Protocol error: {0}")]
-    Protocol(String),
-
-    /// Serialization error
-    #[error("Serialization error: {0}")]
-    Serialization(#[from] serde_json::Error),
-
-    /// Cloudflare API error
-    #[error("Cloudflare API error: {0}")]
-    Cloudflare(String),
-}
-
-#[cfg(feature = "server")]
-impl From<cloudflare::framework::Error> for TlsForwardError {
-    fn from(e: cloudflare::framework::Error) -> Self {
-        TlsForwardError::Cloudflare(e.to_string())
-    }
-}
diff --git a/crates/tlsforward/src/common/mod.rs b/crates/tlsforward/src/common/mod.rs
deleted file mode 100644
index 17ab8eeb..00000000
--- a/crates/tlsforward/src/common/mod.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//! Common types and utilities shared between client and server
-pub mod error;
-pub mod types;
-
-#[cfg(test)]
-pub mod test_utils;
-
-pub use error::{Result, TlsForwardError};
-pub use types::*;
diff --git a/crates/tlsforward/src/common/test_utils.rs b/crates/tlsforward/src/common/test_utils.rs
deleted file mode 100644
index 3ada0c90..00000000
--- a/crates/tlsforward/src/common/test_utils.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-//! Test utilities for connection pool testing
-
-use iroh::endpoint::ConnectionError;
-use std::sync::Arc;
-use tokio::sync::Mutex;
-
-/// Mock connection for testing
-#[derive(Clone, Debug)]
-pub struct TestConnection {
-    pub id: String,
-    pub healthy: Arc<Mutex<bool>>,
-    pub stalled: Arc<Mutex<bool>>,
-}
-
-impl TestConnection {
-    pub fn new(id: &str) -> Self {
-        Self {
-            id: id.to_string(),
-            healthy: Arc::new(Mutex::new(true)),
-            stalled: Arc::new(Mutex::new(false)),
-        }
-    }
-
-    pub async fn is_healthy(&self) -> bool {
-        *self.healthy.lock().await
-    }
-
-    pub async fn set_healthy(&self, healthy: bool) {
-        *self.healthy.lock().await = healthy;
-    }
-
-    pub async fn stall(&self) {
-        *self.stalled.lock().await = true;
-    }
-
-    pub async fn unstall(&self) {
-        *self.stalled.lock().await = false;
-    }
-
-    pub async fn is_stalled(&self) -> bool {
-        *self.stalled.lock().await
-    }
-
-    /// Simulate a connection reset
-    pub async fn reset(&self) {
-        self.set_healthy(false).await;
-    }
-}
-
-// Helper to convert TestConnection to something that looks like an iroh Connection
-// Note: This is a mock implementation for testing only
-impl TestConnection {
-    pub fn close_reason(&self) -> Option<ConnectionError> {
-        // In a real test setup, we'd check if healthy
-        // For now, return None to indicate connection is open
-        None
-    }
-}
diff --git a/crates/tlsforward/src/common/types.rs b/crates/tlsforward/src/common/types.rs
deleted file mode 100644
index 38445389..00000000
--- a/crates/tlsforward/src/common/types.rs
+++ /dev/null
@@ -1,172 +0,0 @@
-//! Common types used by both client and server
-
-use iroh::NodeId;
-use serde::{Deserialize, Serialize};
-
-/// API Error response
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ErrorResponse {
-    /// Error code for programmatic handling
-    pub code: String,
-    /// Human-readable error message
-    pub message: String,
-    /// Optional additional details
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub details: Option<serde_json::Value>,
-}
-
-impl ErrorResponse {
-    pub fn new(code: impl Into<String>, message: impl Into<String>) -> Self {
-        Self {
-            code: code.into(),
-            message: message.into(),
-            details: None,
-        }
-    }
-
-    pub fn with_details(mut self, details: serde_json::Value) -> Self {
-        self.details = Some(details);
-        self
-    }
-}
-
-/// Information about a TLS forward endpoint
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TlsForwardInfo {
-    /// TLS forward node ID
-    pub node_id: NodeId,
-    // /// TLS forward node address
-    // pub node_addr: NodeAddr,
-    /// Domain suffix for TLS forward addresses
-    pub domain_suffix: String,
-}
-
-/// Registration request from a gate server
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RegistrationRequest {}
-
-/// Registration response from TLS forward server
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RegistrationResponse {
-    /// Assigned domain (e.g., "abc123.private.hellas.ai")
-    pub domain: String,
-    /// TLS forward information
-    pub tlsforward_info: TlsForwardInfo,
-}
-
-/// Certificate provisioning status
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum CertificateStatus {
-    /// No certificate needed yet
-    NotRequired,
-    /// Certificate is being provisioned
-    Provisioning,
-    /// Certificate is ready
-    Ready {
-        /// Certificate expiry timestamp
-        expires_at: u64,
-    },
-    /// Certificate provisioning failed
-    Failed {
-        /// Error message
-        error: String,
-    },
-}
-
-// DNS Challenge Management Types
-
-/// Request to create a DNS challenge
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct CreateChallengeRequest {
-    /// The domain for the challenge (e.g., "abc123.private.hellas.ai")
-    pub domain: String,
-    /// The challenge subdomain (typically "_acme-challenge")
-    pub challenge: String,
-    /// The challenge value to set in the TXT record
-    pub value: String,
-}
-
-/// Response for challenge creation
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct CreateChallengeResponse {
-    /// Unique ID for this challenge
-    pub id: String,
-    /// Current status of the challenge
-    pub status: ChallengeStatus,
-}
-
-/// Status of a DNS challenge
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum ChallengeStatus {
-    /// Challenge created but not yet propagated
-    Pending,
-    /// Challenge has propagated to DNS
-    Propagated,
-    /// Challenge failed to create or propagate
-    Failed { error: String },
-}
-
-/// Response for challenge status check
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ChallengeStatusResponse {
-    /// Challenge ID
-    pub id: String,
-    /// Current status
-    pub status: ChallengeStatus,
-    /// Number of successful DNS checks (if propagating)
-    pub checks: u32,
-}
-
-/// Response for challenge deletion
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct DeleteChallengeResponse {
-    /// Challenge ID
-    pub id: String,
-    /// Status after deletion
-    pub status: String,
-}
-
-/// Status response
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct StatusResponse {
-    /// Whether the node is registered
-    pub registered: bool,
-    /// Assigned domain if registered
-    pub domain: Option<String>,
-    /// Number of active connections
-    pub active_connections: usize,
-    /// Uptime in seconds
-    pub uptime_seconds: u64,
-}
-
-/// Empty response type for operations that don't return data
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct EmptyResponse {}
-
-/// Information about a connected node
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ConnectedNode {
-    /// Node ID
-    pub node_id: String,
-    /// Assigned domain
-    pub domain: String,
-    /// Connection timestamp (ISO 8601)
-    pub connected_at: String,
-    /// Uptime in seconds
-    pub uptime_seconds: u64,
-    /// Latency in milliseconds (if measured)
-    pub latency_ms: Option<u64>,
-    /// Last ping timestamp (ISO 8601)
-    pub last_ping: String,
-}
-
-/// Response for listing connected nodes
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ListNodesResponse {
-    /// List of connected nodes
-    pub nodes: Vec<ConnectedNode>,
-    /// Total number of connected nodes
-    pub total: usize,
-}
diff --git a/crates/tlsforward/src/lib.rs b/crates/tlsforward/src/lib.rs
deleted file mode 100644
index 32cd878c..00000000
--- a/crates/tlsforward/src/lib.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//! Gate TLS forward service for HTTPS/TLS proxying over P2P connections
-//!
-//! This crate provides both client and server functionality:
-//! - Server: Standalone TLS forward service that proxies HTTPS traffic
-//! - Client: Library for gate servers to register with TLS forward service
-#[macro_use]
-extern crate tracing;
-
-pub mod common;
-
-#[cfg(feature = "client")]
-pub mod client;
-
-#[cfg(feature = "client")]
-pub use client::{CertificateManager, TlsAcceptorProvider, TlsForwardClient, TlsForwardHandler};
-
-#[cfg(feature = "server")]
-pub mod server;
-
-// Re-export common types at crate root
-pub use common::error;
-pub use error::{Result, TlsForwardError};
-
-/// ALPN protocol identifier for TLS forwarding over Iroh
-pub const TLS_FORWARD_ALPN: &[u8] = b"/gate.tlsforward.v1.TlsForward/1.0";
-
-/// ALPN protocol identifier for HTTP API over Iroh
-pub const TLSFORWARD_HTTP_ALPN: &[u8] = b"/gate.tlsforward.v1.Http/1.0";
diff --git a/crates/tlsforward/src/server/config.rs b/crates/tlsforward/src/server/config.rs
deleted file mode 100644
index a9ed673a..00000000
--- a/crates/tlsforward/src/server/config.rs
+++ /dev/null
@@ -1,272 +0,0 @@
-//! TLS forward server configuration
-
-use config::{Config, ConfigError, Environment, File};
-use serde::{Deserialize, Serialize};
-use std::net::SocketAddr;
-use std::path::Path;
-use std::time::Duration;
-
-/// TLS forward server configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TlsForwardConfig {
-    /// Server settings
-    pub server: ServerConfig,
-    /// P2P settings
-    pub p2p: P2pConfig,
-    /// HTTPS proxy settings
-    pub https_proxy: HttpsProxyConfig,
-    /// DNS settings
-    #[serde(default)]
-    pub dns: DnsConfig,
-}
-
-/// Server configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ServerConfig {
-    /// Log level
-    #[serde(default = "default_log_level")]
-    pub log_level: String,
-    /// Metrics endpoint
-    #[serde(default)]
-    pub metrics_addr: Option<SocketAddr>,
-}
-
-/// P2P configuration
-#[derive(Debug, Default, Clone, Serialize, Deserialize)]
-pub struct P2pConfig {
-    /// P2P bind address
-    #[serde(default)]
-    pub bind_addrs: Vec<SocketAddr>,
-    /// Secret key path (if not provided, generates new)
-    #[serde(default)]
-    pub secret_key_path: Option<String>,
-    /// Enable local network discovery
-    #[serde(default = "default_true")]
-    pub enable_discovery: bool,
-}
-
-/// HTTPS proxy configuration
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct HttpsProxyConfig {
-    /// Bind address for HTTPS proxy
-    #[serde(default = "default_https_addr")]
-    pub bind_addr: SocketAddr,
-    /// Domain suffix for relay addresses
-    #[serde(default = "default_domain_suffix")]
-    pub domain_suffix: String,
-    /// Maximum concurrent connections
-    #[serde(default = "default_max_connections")]
-    pub max_connections: usize,
-    /// Connection timeout in seconds
-    #[serde(default = "default_connection_timeout")]
-    pub connection_timeout_secs: u64,
-}
-
-/// DNS configuration
-#[derive(Debug, Clone, Serialize, Deserialize, Default)]
-pub struct DnsConfig {
-    /// Enable DNS management
-    #[serde(default)]
-    pub enabled: bool,
-    /// DNS provider
-    #[serde(default)]
-    pub provider: DnsProvider,
-    /// Cloudflare configuration
-    #[serde(default)]
-    pub cloudflare: CloudflareConfig,
-}
-
-/// DNS provider
-#[derive(Debug, Clone, Serialize, Deserialize, Default)]
-#[serde(rename_all = "lowercase")]
-pub enum DnsProvider {
-    #[default]
-    None,
-    Cloudflare,
-}
-
-/// Cloudflare configuration
-#[derive(Debug, Clone, Serialize, Deserialize, Default)]
-pub struct CloudflareConfig {
-    /// Zone ID
-    pub zone_id: Option<String>,
-    /// API token
-    pub api_token: Option<String>,
-}
-
-fn default_log_level() -> String {
-    "info".to_string()
-}
-
-fn default_true() -> bool {
-    true
-}
-
-fn default_https_addr() -> SocketAddr {
-    ([0, 0, 0, 0], 443).into()
-}
-
-fn default_domain_suffix() -> String {
-    "private.hellas.ai".to_string()
-}
-
-fn default_max_connections() -> usize {
-    1000
-}
-
-fn default_connection_timeout() -> u64 {
-    10
-}
-
-impl Default for TlsForwardConfig {
-    fn default() -> Self {
-        Self {
-            server: ServerConfig {
-                log_level: default_log_level(),
-                metrics_addr: None,
-            },
-            p2p: P2pConfig::default(),
-            https_proxy: HttpsProxyConfig {
-                bind_addr: default_https_addr(),
-                domain_suffix: default_domain_suffix(),
-                max_connections: default_max_connections(),
-                connection_timeout_secs: default_connection_timeout(),
-            },
-            dns: DnsConfig::default(),
-        }
-    }
-}
-
-impl TlsForwardConfig {
-    /// Load configuration from environment and files
-    pub fn load() -> Result<Self, ConfigError> {
-        let mut builder = Config::builder();
-
-        // Try to find config files in common locations
-        let config_paths = [
-            "relay.toml",
-            "config/relay.toml",
-            "/etc/gate/relay.toml",
-            "gate.toml", // Also check main gate config
-            "config/gate.toml",
-            "/etc/gate/gate.toml",
-        ];
-
-        for path in &config_paths {
-            if Path::new(path).exists() {
-                builder = builder.add_source(File::with_name(path).required(false));
-            }
-        }
-
-        // Add environment variables with RELAY_ prefix
-        builder = builder.add_source(
-            Environment::with_prefix("RELAY")
-                .separator("__")
-                .try_parsing(true),
-        );
-
-        let config = builder.build()?;
-        config.try_deserialize()
-    }
-
-    /// Load configuration from a specific config file
-    pub fn load_from_file(path: &str) -> Result<Self, ConfigError> {
-        let mut builder = Config::builder();
-
-        // Start with defaults
-        builder = builder.add_source(Config::try_from(&TlsForwardConfig::default())?);
-
-        // Add the specific config file
-        builder = builder.add_source(File::with_name(path));
-
-        // Add environment variables with RELAY_ prefix (can override file settings)
-        builder = builder.add_source(
-            Environment::with_prefix("RELAY")
-                .separator("__")
-                .try_parsing(true),
-        );
-
-        let config = builder.build()?;
-        config.try_deserialize()
-    }
-}
-
-/// Timeout configuration for various proxy operations
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ProxyTimeouts {
-    /// Timeout for reading SNI from incoming TLS connection
-    #[serde(default = "default_sni_read_timeout")]
-    pub sni_read: Duration,
-
-    /// Timeout for establishing P2P connection to target node
-    #[serde(default = "default_connect_timeout")]
-    pub connect: Duration,
-
-    /// Timeout for copying data between streams
-    #[serde(default = "default_stream_copy_timeout")]
-    pub stream_copy: Duration,
-
-    /// Timeout for DNS operations (if using Cloudflare)
-    #[serde(default = "default_dns_operation_timeout")]
-    pub dns_operation: Duration,
-
-    /// Idle timeout for connections
-    #[serde(default = "default_idle_timeout")]
-    pub idle: Duration,
-}
-
-impl Default for ProxyTimeouts {
-    fn default() -> Self {
-        Self {
-            sni_read: default_sni_read_timeout(),
-            connect: default_connect_timeout(),
-            stream_copy: default_stream_copy_timeout(),
-            dns_operation: default_dns_operation_timeout(),
-            idle: default_idle_timeout(),
-        }
-    }
-}
-
-impl ProxyTimeouts {
-    /// Create a new timeout configuration with all values set to the same duration
-    pub fn all(duration: Duration) -> Self {
-        Self {
-            sni_read: duration,
-            connect: duration,
-            stream_copy: duration,
-            dns_operation: duration,
-            idle: duration,
-        }
-    }
-
-    /// Create timeout configuration suitable for testing
-    pub fn for_testing() -> Self {
-        Self {
-            sni_read: Duration::from_secs(1),
-            connect: Duration::from_secs(5),
-            stream_copy: Duration::from_secs(60),
-            dns_operation: Duration::from_secs(10),
-            idle: Duration::from_secs(120),
-        }
-    }
-}
-
-fn default_sni_read_timeout() -> Duration {
-    Duration::from_secs(5)
-}
-
-fn default_connect_timeout() -> Duration {
-    Duration::from_secs(10)
-}
-
-fn default_stream_copy_timeout() -> Duration {
-    Duration::from_secs(300) // 5 minutes
-}
-
-fn default_dns_operation_timeout() -> Duration {
-    Duration::from_secs(30)
-}
-
-fn default_idle_timeout() -> Duration {
-    Duration::from_secs(600) // 10 minutes
-}
diff --git a/crates/tlsforward/src/server/dns.rs b/crates/tlsforward/src/server/dns.rs
deleted file mode 100644
index 78dc86a8..00000000
--- a/crates/tlsforward/src/server/dns.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-//! DNS management for relay service
-use crate::common::error::Result;
-use std::sync::Arc;
-
-/// DNS manager interface
-#[async_trait::async_trait]
-pub trait DnsManager: Send + Sync {
-    /// Create or update a DNS record
-    async fn upsert_record(&self, subdomain: &str, ip: &str) -> Result<()>;
-
-    /// Delete a DNS record
-    async fn delete_record(&self, subdomain: &str) -> Result<()>;
-}
-
-/// No-op DNS manager for when DNS management is disabled
-pub struct NoOpDnsManager;
-
-#[async_trait::async_trait]
-impl DnsManager for NoOpDnsManager {
-    async fn upsert_record(&self, subdomain: &str, ip: &str) -> Result<()> {
-        warn!(
-            "DNS management disabled: not updating {} -> {}",
-            subdomain, ip
-        );
-        Ok(())
-    }
-
-    async fn delete_record(&self, subdomain: &str) -> Result<()> {
-        warn!("DNS management disabled: not deleting {}", subdomain);
-        Ok(())
-    }
-}
-
-#[cfg(feature = "server")]
-pub mod cloudflare {
-    use super::*;
-    use tracing::info;
-    // use cloudflare::endpoints::{dns, zone};
-    use ::cloudflare::framework::{
-        Environment,
-        auth::Credentials,
-        client::{ClientConfig, async_api::Client as CfClient},
-    };
-
-    /// Cloudflare DNS manager
-    pub struct CloudflareDnsManager {
-        _client: CfClient,
-        _zone_id: String,
-        domain_suffix: String,
-    }
-
-    impl CloudflareDnsManager {
-        /// Create a new Cloudflare DNS manager
-        pub fn new(api_token: String, zone_id: String, domain_suffix: String) -> Result<Self> {
-            let credentials = Credentials::UserAuthToken { token: api_token };
-            let client = CfClient::new(
-                credentials,
-                ClientConfig::default(),
-                Environment::Production,
-            )?;
-
-            Ok(Self {
-                _client: client,
-                _zone_id: zone_id,
-                domain_suffix,
-            })
-        }
-
-        fn full_domain(&self, subdomain: &str) -> String {
-            format!("{}.{}", subdomain, self.domain_suffix)
-        }
-    }
-
-    #[async_trait::async_trait]
-    impl DnsManager for CloudflareDnsManager {
-        async fn upsert_record(&self, subdomain: &str, ip: &str) -> Result<()> {
-            let name = self.full_domain(subdomain);
-
-            // TODO: Implement Cloudflare API calls
-            info!("Would create DNS A record: {} -> {}", name, ip);
-
-            Ok(())
-        }
-
-        async fn delete_record(&self, subdomain: &str) -> Result<()> {
-            let name = self.full_domain(subdomain);
-
-            // TODO: Implement Cloudflare API calls
-            info!("Would delete DNS record: {}", name);
-
-            Ok(())
-        }
-    }
-}
-
-/// Create a DNS manager based on configuration
-pub fn create_dns_manager(
-    config: &crate::server::config::DnsConfig,
-    domain_suffix: String,
-) -> Arc<dyn DnsManager> {
-    match config.provider {
-        crate::server::config::DnsProvider::Cloudflare => {
-            #[cfg(feature = "server")]
-            {
-                if let (Some(zone_id), Some(api_token)) =
-                    (&config.cloudflare.zone_id, &config.cloudflare.api_token)
-                {
-                    match cloudflare::CloudflareDnsManager::new(
-                        api_token.clone(),
-                        zone_id.clone(),
-                        domain_suffix,
-                    ) {
-                        Ok(manager) => return Arc::new(manager),
-                        Err(e) => {
-                            warn!("Failed to create Cloudflare DNS manager: {}", e);
-                        }
-                    }
-                } else {
-                    warn!("Cloudflare DNS enabled but missing configuration");
-                }
-            }
-            #[cfg(not(feature = "server"))]
-            {
-                let _ = domain_suffix; // Suppress unused warning when cloudflare feature is disabled
-            }
-        }
-        _ => {
-            let _ = domain_suffix; // Suppress unused warning for other providers
-        }
-    }
-
-    Arc::new(NoOpDnsManager)
-}
diff --git a/crates/tlsforward/src/server/dns_challenge.rs b/crates/tlsforward/src/server/dns_challenge.rs
deleted file mode 100644
index 5f859919..00000000
--- a/crates/tlsforward/src/server/dns_challenge.rs
+++ /dev/null
@@ -1,530 +0,0 @@
-//! DNS challenge management for ACME (Let's Encrypt)
-//!
-//! This module handles DNS-01 challenges by managing TXT records via Cloudflare.
-
-use anyhow::{Result, anyhow};
-use cloudflare::endpoints::dns::dns::{
-    CreateDnsRecord, CreateDnsRecordParams, DeleteDnsRecord, DnsContent,
-};
-use cloudflare::framework::{
-    Environment,
-    auth::Credentials,
-    client::{ClientConfig, async_api::Client as CfClient},
-    response::ApiFailure,
-};
-use iroh::NodeId;
-use std::collections::HashMap;
-use std::sync::Arc;
-use tokio::sync::RwLock;
-use uuid::Uuid;
-
-use crate::common::ChallengeStatus;
-
-/// DNS challenge data
-#[derive(Debug, Clone)]
-pub struct DnsChallenge {
-    /// The domain for the challenge
-    pub domain: String,
-    /// The challenge subdomain (typically "_acme-challenge")
-    pub challenge: String,
-    /// The challenge value to set
-    pub value: String,
-}
-
-/// Internal challenge state
-#[derive(Debug, Clone)]
-struct ChallengeState {
-    /// Node ID that created this challenge
-    owner_node_id: NodeId,
-    /// Cloudflare record ID (once created)
-    record_id: Option<String>,
-    /// Current status
-    status: ChallengeStatus,
-    /// Number of successful propagation checks
-    checks: u32,
-    /// The full DNS record name (e.g., "_acme-challenge.subdomain.domain.com")
-    record_name: String,
-    /// The expected TXT value
-    txt_value: String,
-}
-
-/// Manager for DNS challenges using Cloudflare
-pub struct DnsChallengeManager {
-    /// Cloudflare API client
-    cf_client: Arc<CfClient>,
-    /// Cloudflare zone ID
-    zone_id: String,
-    /// Base domain (e.g., "private.hellas.ai")
-    base_domain: String,
-    /// Cloudflare zone domain (e.g., "hellas.ai")
-    zone_domain: String,
-    /// Active challenges
-    challenges: Arc<RwLock<HashMap<String, ChallengeState>>>,
-}
-
-impl DnsChallengeManager {
-    /// Create a new DNS challenge manager
-    pub fn new(api_token: String, zone_id: String, base_domain: String) -> Result<Self> {
-        let credentials = Credentials::UserAuthToken { token: api_token };
-
-        let cf_client = CfClient::new(
-            credentials,
-            ClientConfig::default(),
-            Environment::Production,
-        )?;
-
-        // Extract zone domain from base domain
-        // If base_domain is "private.hellas.ai", zone_domain is "hellas.ai"
-        let zone_domain = if base_domain.contains('.') {
-            // Find the last two parts (TLD and domain)
-            let parts: Vec<&str> = base_domain.split('.').collect();
-            if parts.len() >= 2 {
-                let second_last = parts[parts.len() - 2];
-                let last = parts[parts.len() - 1];
-                format!("{second_last}.{last}")
-            } else {
-                base_domain.clone()
-            }
-        } else {
-            base_domain.clone()
-        };
-
-        info!("DNS Challenge Manager: base_domain={base_domain}, zone_domain={zone_domain}");
-
-        Ok(Self {
-            cf_client: Arc::new(cf_client),
-            zone_id,
-            base_domain,
-            zone_domain,
-            challenges: Arc::new(RwLock::new(HashMap::new())),
-        })
-    }
-
-    /// Validate that a domain matches our expected pattern
-    pub fn validate_domain(&self, domain: &str) -> bool {
-        // Domain should end with our base domain
-        domain.ends_with(&format!(".{}", self.base_domain))
-    }
-
-    /// Create a new DNS challenge
-    pub async fn create_challenge(
-        &self,
-        challenge: DnsChallenge,
-        owner_node_id: NodeId,
-    ) -> Result<String> {
-        // Generate unique ID for this challenge
-        let id = Uuid::new_v4().to_string();
-
-        info!(
-            "DnsChallengeManager: Creating challenge {id} for domain {} (owner: {owner_node_id})",
-            challenge.domain
-        );
-
-        // Extract subdomain from the full domain
-        // If challenge.domain is "09793852586a678a.private.hellas.ai" and base_domain is "private.hellas.ai",
-        // we need to extract "09793852586a678a.private" to create the record in the hellas.ai zone
-        let record_name = if challenge
-            .domain
-            .ends_with(&format!(".{}", self.base_domain))
-        {
-            // Remove the base domain suffix to get just the subdomain
-            let subdomain_len = challenge.domain.len() - self.base_domain.len() - 1;
-            let subdomain = &challenge.domain[..subdomain_len];
-
-            // Now we need to handle the zone difference
-            // If base_domain is "private.hellas.ai" and zone_domain is "hellas.ai",
-            // we need to keep the "private" part in the record name
-            if self.base_domain != self.zone_domain
-                && self
-                    .base_domain
-                    .ends_with(&format!(".{}", self.zone_domain))
-            {
-                // Extract the middle part (e.g., "private" from "private.hellas.ai")
-                let middle_len = self.base_domain.len() - self.zone_domain.len() - 1;
-                let middle_part = &self.base_domain[..middle_len];
-                let challenge_name = &challenge.challenge;
-                format!("{challenge_name}.{subdomain}.{middle_part}")
-            } else {
-                let challenge_name = &challenge.challenge;
-                format!("{challenge_name}.{subdomain}")
-            }
-        } else {
-            return Err(anyhow!(
-                "Domain {} does not match base domain {}",
-                challenge.domain,
-                self.base_domain
-            ));
-        };
-
-        let zone_domain = &self.zone_domain;
-        let value = &challenge.value;
-        info!("Creating TXT record: {record_name} (in zone {zone_domain}) = {value}");
-
-        // Create the DNS record via Cloudflare
-        let params = CreateDnsRecordParams {
-            name: &record_name,
-            content: DnsContent::TXT {
-                content: challenge.value.clone(),
-            },
-            ttl: Some(120),
-            proxied: Some(false),
-            priority: None,
-        };
-
-        let zone_id = &self.zone_id;
-        debug!("Sending request to Cloudflare API for zone {zone_id}");
-        match self
-            .cf_client
-            .request(&CreateDnsRecord {
-                zone_identifier: &self.zone_id,
-                params,
-            })
-            .await
-        {
-            Ok(response) => {
-                let record_id = response.result.id;
-                info!("Successfully created DNS record with ID: {record_id}");
-
-                // Store challenge state with DNS record details
-                let zone_domain = &self.zone_domain;
-                let state = ChallengeState {
-                    owner_node_id,
-                    record_id: Some(record_id),
-                    status: ChallengeStatus::Pending,
-                    checks: 0,
-                    record_name: format!("{record_name}.{zone_domain}"),
-                    txt_value: challenge.value.clone(),
-                };
-
-                self.challenges.write().await.insert(id.clone(), state);
-
-                // Start background task to check propagation
-                self.spawn_propagation_checker(id.clone());
-
-                Ok(id)
-            }
-            Err(e) => {
-                tracing::error!("Failed to create DNS record: {e:?}");
-                // Log detailed error information
-                let error_msg = match e {
-                    ApiFailure::Error(status, api_errors) => {
-                        error!("Cloudflare API error (HTTP {status}): {api_errors:?}");
-                        // Log each error detail
-                        for err in &api_errors.errors {
-                            let code = &err.code;
-                            let message = &err.message;
-                            let other = &err.other;
-                            error!("  Error {code}: {message} (other: {other:?})");
-                        }
-                        // Log any additional error information
-                        for (k, v) in &api_errors.other {
-                            error!("  {k}: {v}");
-                        }
-                        let error_message = api_errors
-                            .errors
-                            .first()
-                            .map(|e| e.message.as_str())
-                            .unwrap_or("Unknown error");
-                        format!("Cloudflare API error (HTTP {status}): {error_message}")
-                    }
-                    ApiFailure::Invalid(req_err) => {
-                        error!("Request error creating DNS record: {req_err}");
-                        format!("Request error: {req_err}")
-                    }
-                };
-
-                error!("Failed to create DNS record '{record_name}': {error_msg}");
-
-                // Store failed state
-                let zone_domain = &self.zone_domain;
-                let state = ChallengeState {
-                    owner_node_id,
-                    record_id: None,
-                    status: ChallengeStatus::Failed {
-                        error: error_msg.clone(),
-                    },
-                    checks: 0,
-                    record_name: format!("{record_name}.{zone_domain}"),
-                    txt_value: challenge.value.clone(),
-                };
-
-                self.challenges.write().await.insert(id.clone(), state);
-
-                Err(anyhow!(
-                    "Failed to create DNS record '{record_name}': {error_msg}"
-                ))
-            }
-        }
-    }
-
-    /// Get the status of a challenge
-    pub async fn get_challenge_status(
-        &self,
-        id: &str,
-        requester_node_id: &NodeId,
-    ) -> Result<(ChallengeStatus, u32)> {
-        let challenges = self.challenges.read().await;
-        let state = challenges
-            .get(id)
-            .ok_or_else(|| anyhow!("Challenge not found"))?;
-
-        // Verify the requester owns this challenge
-        if state.owner_node_id != *requester_node_id {
-            return Err(anyhow!("Challenge not found")); // Don't reveal it exists
-        }
-
-        Ok((state.status.clone(), state.checks))
-    }
-
-    /// Delete a DNS challenge
-    pub async fn delete_challenge(&self, id: &str, requester_node_id: &NodeId) -> Result<()> {
-        let mut challenges = self.challenges.write().await;
-
-        // First check if it exists and verify ownership
-        let state = challenges
-            .get(id)
-            .ok_or_else(|| anyhow!("Challenge not found"))?;
-
-        // Verify the requester owns this challenge
-        if state.owner_node_id != *requester_node_id {
-            return Err(anyhow!("Challenge not found")); // Don't reveal it exists
-        }
-
-        // Now remove it
-        let state = challenges.remove(id).unwrap();
-
-        // Delete from Cloudflare if we have a record ID
-        if let Some(record_id) = state.record_id {
-            info!("Deleting DNS record: {record_id}");
-
-            match self
-                .cf_client
-                .request(&DeleteDnsRecord {
-                    zone_identifier: &self.zone_id,
-                    identifier: &record_id,
-                })
-                .await
-            {
-                Ok(_) => info!("Successfully deleted DNS record: {record_id}"),
-                Err(e) => {
-                    let error_msg = match e {
-                        ApiFailure::Error(status, api_errors) => {
-                            error!(
-                                "Cloudflare API error deleting DNS record (HTTP {status}): {api_errors:?}"
-                            );
-                            let error_message = api_errors
-                                .errors
-                                .first()
-                                .map(|e| e.message.as_str())
-                                .unwrap_or("Unknown error");
-                            format!("Cloudflare API error (HTTP {status}): {error_message}")
-                        }
-                        ApiFailure::Invalid(req_err) => {
-                            error!("Request error deleting DNS record: {req_err}");
-                            format!("Request error: {req_err}")
-                        }
-                    };
-                    return Err(anyhow!("Failed to delete DNS record: {error_msg}"));
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Spawn a task to check DNS propagation
-    fn spawn_propagation_checker(&self, challenge_id: String) {
-        let challenges = self.challenges.clone();
-
-        tokio::spawn(async move {
-            let mut checks = 0;
-            const MAX_CHECKS: u32 = 30; // 5 minutes max
-            const CHECK_INTERVAL: std::time::Duration = std::time::Duration::from_secs(10);
-
-            loop {
-                tokio::time::sleep(CHECK_INTERVAL).await;
-                checks += 1;
-
-                // Get challenge info
-                let mut challenges_lock = challenges.write().await;
-                if let Some(state) = challenges_lock.get_mut(&challenge_id) {
-                    // Check DNS propagation using the stored record details
-                    let propagated =
-                        check_dns_propagation(&state.record_name, &state.txt_value).await;
-
-                    if propagated {
-                        let seconds = checks * 10;
-                        info!("Challenge {challenge_id} has propagated after {seconds} seconds");
-                        state.status = ChallengeStatus::Propagated;
-                        state.checks = checks;
-                        break;
-                    }
-
-                    state.checks = checks;
-
-                    if checks >= MAX_CHECKS {
-                        warn!("Challenge {challenge_id} timed out waiting for propagation");
-                        state.status = ChallengeStatus::Failed {
-                            error: "DNS propagation timeout".to_string(),
-                        };
-                        break;
-                    }
-                } else {
-                    // Challenge was deleted
-                    debug!("Challenge {challenge_id} no longer exists");
-                    break;
-                }
-            }
-        });
-    }
-}
-
-/// Check if DNS record has propagated
-async fn check_dns_propagation(record_name: &str, expected_value: &str) -> bool {
-    use trust_dns_resolver::{TokioAsyncResolver, config::*};
-
-    // Use Cloudflare's DNS over TLS for faster resolution
-    let resolver = TokioAsyncResolver::tokio(ResolverConfig::cloudflare(), ResolverOpts::default());
-
-    debug!("Checking DNS propagation for {record_name} = {expected_value}");
-
-    match resolver.txt_lookup(record_name).await {
-        Ok(response) => {
-            for txt_data in response.iter() {
-                let txt_value = txt_data.to_string();
-
-                debug!("Found TXT record: {record_name} = {txt_value}");
-
-                // DNS servers may or may not include quotes in the response
-                // Compare the actual content without quotes
-                let normalized_txt = txt_value.trim_matches('"');
-                let normalized_expected = expected_value.trim_matches('"');
-
-                debug!(
-                    "Comparing DNS values - found: '{txt_value}' (normalized: '{normalized_txt}'), expected: '{expected_value}' (normalized: '{normalized_expected}')"
-                );
-
-                if normalized_txt == normalized_expected {
-                    info!("DNS propagation confirmed for {record_name}");
-                    return true;
-                }
-            }
-            debug!("DNS record found but value doesn't match for {record_name}");
-            false
-        }
-        Err(e) => {
-            debug!("DNS lookup failed for {record_name}: {e}");
-            false
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    #[test]
-    fn test_zone_domain_extraction() {
-        // Test that we correctly extract the zone domain from the base domain
-        let test_cases = vec![
-            ("private.hellas.ai", "hellas.ai"),
-            ("subdomain.example.com", "example.com"),
-            ("deep.sub.domain.co.uk", "co.uk"),
-            ("example.com", "example.com"),
-            ("localhost", "localhost"),
-        ];
-
-        for (base_domain, expected_zone) in test_cases {
-            let parts: Vec<&str> = base_domain.split('.').collect();
-            let zone_domain = if parts.len() >= 2 {
-                format!("{}.{}", parts[parts.len() - 2], parts[parts.len() - 1])
-            } else {
-                base_domain.to_string()
-            };
-
-            assert_eq!(
-                zone_domain, expected_zone,
-                "Failed for base_domain: {base_domain}"
-            );
-        }
-    }
-
-    #[test]
-    fn test_record_name_construction() {
-        // Test the record name construction logic
-        let test_cases = vec![
-            // (domain, base_domain, zone_domain, challenge, expected_record_name)
-            (
-                "xxxxxx.private.hellas.ai",
-                "private.hellas.ai",
-                "hellas.ai",
-                "_acme-challenge",
-                "_acme-challenge.xxxxxx.private",
-            ),
-            (
-                "test.example.com",
-                "example.com",
-                "example.com",
-                "_acme-challenge",
-                "_acme-challenge.test",
-            ),
-            (
-                "sub.domain.example.com",
-                "domain.example.com",
-                "example.com",
-                "_acme-challenge",
-                "_acme-challenge.sub.domain",
-            ),
-        ];
-
-        for (domain, base_domain, zone_domain, challenge, expected) in test_cases {
-            // Simulate the record name construction logic
-            let record_name = if domain.ends_with(&format!(".{base_domain}")) {
-                let subdomain_len = domain.len() - base_domain.len() - 1;
-                let subdomain = &domain[..subdomain_len];
-
-                if base_domain != zone_domain && base_domain.ends_with(&format!(".{zone_domain}")) {
-                    let middle_len = base_domain.len() - zone_domain.len() - 1;
-                    let middle_part = &base_domain[..middle_len];
-                    format!("{challenge}.{subdomain}.{middle_part}")
-                } else {
-                    format!("{challenge}.{subdomain}")
-                }
-            } else {
-                panic!("Domain {domain} does not match base domain {base_domain}");
-            };
-
-            assert_eq!(
-                record_name, expected,
-                "Failed for domain: {domain}, base: {base_domain}, zone: {zone_domain}"
-            );
-        }
-    }
-
-    #[tokio::test]
-    async fn test_dns_propagation_check_quote_handling() {
-        // Test that the DNS propagation check handles quotes correctly
-
-        // Test various quote scenarios
-        let test_cases = vec![
-            // (dns_value, expected_value, should_match)
-            ("test-value", "test-value", true),
-            ("\"test-value\"", "test-value", true),
-            ("test-value", "\"test-value\"", true),
-            ("\"test-value\"", "\"test-value\"", true),
-            ("different-value", "test-value", false),
-            ("\"different-value\"", "test-value", false),
-        ];
-
-        for (dns_value, expected_value, should_match) in test_cases {
-            // Simulate the comparison logic from check_dns_propagation
-            let normalized_dns = dns_value.trim_matches('"');
-            let normalized_expected = expected_value.trim_matches('"');
-            let matches = normalized_dns == normalized_expected;
-
-            assert_eq!(
-                matches, should_match,
-                "Failed for dns_value: '{dns_value}', expected: '{expected_value}', should_match: {should_match}"
-            );
-        }
-    }
-}
diff --git a/crates/tlsforward/src/server/dns_challenge_tests.rs b/crates/tlsforward/src/server/dns_challenge_tests.rs
deleted file mode 100644
index 1ffb9133..00000000
--- a/crates/tlsforward/src/server/dns_challenge_tests.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//! Tests for DNS challenge security
-
-#[cfg(test)]
-mod tests {
-    use crate::common::ChallengeStatus;
-    use crate::server::dns_challenge::DnsChallenge;
-
-    // Since we can't create a DnsChallengeManager directly in tests due to private fields,
-    // we'll test the public API behavior through integration with the router module
-
-    #[test]
-    fn test_challenge_creation_validation() {
-        // Test that DNS challenge creation enforces proper domain structure
-        let challenge = DnsChallenge {
-            domain: "test.private.hellas.ai".to_string(),
-            challenge: "_acme-challenge".to_string(),
-            value: "test-value".to_string(),
-        };
-
-        // Verify the challenge structure
-        assert_eq!(challenge.domain, "test.private.hellas.ai");
-        assert_eq!(challenge.challenge, "_acme-challenge");
-        assert_eq!(challenge.value, "test-value");
-    }
-
-    #[test]
-    fn test_challenge_status_variants() {
-        // Test that all challenge status variants work correctly
-        let pending = ChallengeStatus::Pending;
-        let propagated = ChallengeStatus::Propagated;
-        let failed = ChallengeStatus::Failed {
-            error: "test error".to_string(),
-        };
-
-        assert!(matches!(pending, ChallengeStatus::Pending));
-        assert!(matches!(propagated, ChallengeStatus::Propagated));
-        assert!(matches!(failed, ChallengeStatus::Failed { .. }));
-    }
-}
diff --git a/crates/tlsforward/src/server/http_handler.rs b/crates/tlsforward/src/server/http_handler.rs
deleted file mode 100644
index e6b3ea42..00000000
--- a/crates/tlsforward/src/server/http_handler.rs
+++ /dev/null
@@ -1,175 +0,0 @@
-//! HTTP protocol handler for serving REST APIs over Iroh P2P connections
-
-use crate::server::dns_challenge::DnsChallengeManager;
-use crate::server::registry::ProxyRegistry;
-use crate::server::router::{ApiState, create_api_router};
-use gate_core::tracing::metrics::{counter, gauge};
-use gate_p2p::stream::CombinedStream;
-use hyper_util::rt::TokioExecutor;
-use hyper_util::server;
-use iroh::{
-    endpoint::Connection,
-    protocol::{AcceptError, ProtocolHandler},
-};
-use std::sync::Arc;
-use tower::Service;
-
-/// HTTP protocol handler that serves REST APIs over P2P connections
-pub struct TlsForwardHttpHandler {
-    /// DNS challenge manager for ACME operations
-    dns_manager: Arc<DnsChallengeManager>,
-    /// Proxy registry for node registration
-    registry: Arc<ProxyRegistry>,
-    /// Domain suffix for TLS forward
-    domain_suffix: String,
-    /// The TLS forward server's own node ID
-    tlsforward_node_id: iroh::NodeId,
-}
-
-impl TlsForwardHttpHandler {
-    /// Create a new HTTP protocol handler
-    pub fn new(
-        dns_manager: Arc<DnsChallengeManager>,
-        registry: Arc<ProxyRegistry>,
-        domain_suffix: String,
-        tlsforward_node_id: iroh::NodeId,
-    ) -> Self {
-        Self {
-            dns_manager,
-            registry,
-            domain_suffix,
-            tlsforward_node_id,
-        }
-    }
-}
-
-impl std::fmt::Debug for TlsForwardHttpHandler {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("TlsForwardHttpHandler").finish()
-    }
-}
-
-impl ProtocolHandler for TlsForwardHttpHandler {
-    async fn accept(&self, connection: Connection) -> Result<(), AcceptError> {
-        let node_id = connection.remote_node_id()?;
-
-        info!("HTTP connection from node {}", node_id);
-
-        // Accept multiple bidirectional streams on this connection
-        loop {
-            // Add timeout to prevent hanging on accept_bi
-            match tokio::time::timeout(std::time::Duration::from_secs(30), connection.accept_bi())
-                .await
-            {
-                Ok(Ok((send_stream, recv_stream))) => {
-                    debug!("Accepted HTTP stream from {}", node_id);
-
-                    // Clone dependencies for the spawned task
-                    let dns_manager = self.dns_manager.clone();
-                    let registry = self.registry.clone();
-                    let domain_suffix = self.domain_suffix.clone();
-                    let tlsforward_node_id = self.tlsforward_node_id;
-
-                    // Spawn a task to handle this HTTP request
-                    tokio::spawn(async move {
-                        // Track HTTP API requests
-                        gauge("tlsforward_http_requests_active").increment();
-                        counter("tlsforward_http_requests_total").increment();
-
-                        let result = handle_http_stream(
-                            recv_stream,
-                            send_stream,
-                            dns_manager,
-                            registry,
-                            domain_suffix,
-                            node_id,
-                            tlsforward_node_id,
-                        )
-                        .await;
-
-                        gauge("tlsforward_http_requests_active").decrement();
-
-                        if let Err(e) = result {
-                            counter("tlsforward_http_requests_errors").increment();
-                            error!("Error handling HTTP stream: {}", e);
-                        }
-                    });
-                }
-                Ok(Err(e)) => {
-                    // Connection closed or error
-                    debug!("HTTP connection closed: {}", e);
-                    break;
-                }
-                Err(_) => {
-                    // Timeout waiting for new stream
-                    debug!("Timeout waiting for new HTTP stream from {}", node_id);
-                    break;
-                }
-            }
-        }
-
-        Ok(())
-    }
-}
-
-/// Handle a single HTTP request/response over a bidirectional stream
-#[allow(clippy::too_many_arguments)]
-#[instrument(
-    name = "handle_http_stream",
-    skip_all,
-    fields(
-        node_id = %node_id,
-        protocol = "HTTP",
-        domain_suffix = %domain_suffix
-    )
-)]
-async fn handle_http_stream(
-    recv_stream: iroh::endpoint::RecvStream,
-    send_stream: iroh::endpoint::SendStream,
-    dns_manager: Arc<DnsChallengeManager>,
-    registry: Arc<ProxyRegistry>,
-    domain_suffix: String,
-    node_id: iroh::NodeId,
-    tlsforward_node_id: iroh::NodeId,
-) -> anyhow::Result<()> {
-    // Combine the streams
-    let stream = CombinedStream::new(recv_stream, send_stream);
-
-    // Wrap the stream for hyper compatibility
-    let io = hyper_util::rt::TokioIo::new(stream);
-
-    // Create the API state
-    let api_state = ApiState {
-        dns_manager,
-        registry,
-        domain_suffix,
-        tlsforward_node_id,
-    };
-
-    // Create the router and apply state
-    let router = create_api_router()
-        .layer(axum::extract::Extension(node_id))
-        .with_state(api_state);
-
-    // Create the service function
-    let hyper_service =
-        hyper::service::service_fn(move |request: hyper::Request<hyper::body::Incoming>| {
-            router.clone().call(request)
-        });
-
-    // Serve the connection using hyper's low-level API
-    match server::conn::auto::Builder::new(TokioExecutor::new())
-        .serve_connection(io, hyper_service)
-        .await
-    {
-        Ok(()) => {
-            debug!("HTTP connection completed successfully");
-        }
-        Err(e) => {
-            error!("HTTP connection error: {}", e);
-            return Err(anyhow::anyhow!("HTTP connection error: {}", e));
-        }
-    }
-
-    Ok(())
-}
diff --git a/crates/tlsforward/src/server/https_proxy.rs b/crates/tlsforward/src/server/https_proxy.rs
deleted file mode 100644
index 32866d66..00000000
--- a/crates/tlsforward/src/server/https_proxy.rs
+++ /dev/null
@@ -1,244 +0,0 @@
-//! HTTPS proxy server that forwards TLS traffic over P2P connections
-
-use crate::TLS_FORWARD_ALPN;
-use crate::common::error::Result;
-use crate::server::config::ProxyTimeouts;
-use crate::server::registry::ProxyRegistry;
-use crate::server::sni::extract_sni;
-use gate_core::tracing::{
-    metrics::{counter, gauge, histogram},
-    prelude::*,
-};
-use gate_p2p::stream::{CombinedStream, StreamUtils};
-use iroh::Endpoint;
-use std::net::SocketAddr;
-use std::sync::Arc;
-use tokio::net::{TcpListener, TcpStream};
-use tokio::time::timeout;
-
-/// HTTPS proxy server configuration
-#[derive(Debug, Clone)]
-pub struct HttpsProxyConfig {
-    /// Address to bind the HTTPS proxy to
-    pub bind_addr: SocketAddr,
-    /// Timeouts for various operations
-    pub timeouts: ProxyTimeouts,
-    /// Maximum concurrent connections
-    pub max_connections: usize,
-    /// Buffer size for copying data
-    pub buffer_size: usize,
-}
-
-impl Default for HttpsProxyConfig {
-    fn default() -> Self {
-        Self {
-            // Use :: for dual-stack IPv4/IPv6 support
-            bind_addr: "[::]:443"
-                .parse()
-                .unwrap_or_else(|_| ([0, 0, 0, 0], 443).into()),
-            timeouts: ProxyTimeouts::default(),
-            max_connections: 1000,
-            buffer_size: 16 * 1024, // 16KB
-        }
-    }
-}
-
-/// HTTPS proxy server that forwards TLS traffic to P2P nodes
-pub struct HttpsProxy {
-    config: HttpsProxyConfig,
-    registry: ProxyRegistry,
-    endpoint: Endpoint,
-}
-
-impl HttpsProxy {
-    /// Create a new HTTPS proxy
-    pub fn new(config: HttpsProxyConfig, registry: ProxyRegistry, endpoint: Endpoint) -> Self {
-        Self {
-            config,
-            registry,
-            endpoint,
-        }
-    }
-
-    /// Start the HTTPS proxy server
-    pub async fn start(self: Arc<Self>) -> Result<()> {
-        let listener = TcpListener::bind(self.config.bind_addr).await?;
-        info!("HTTPS proxy listening on {}", self.config.bind_addr);
-
-        // Connection semaphore to limit concurrent connections
-        let semaphore = Arc::new(tokio::sync::Semaphore::new(self.config.max_connections));
-
-        loop {
-            let (stream, peer_addr) = listener.accept().await?;
-            let proxy = self.clone();
-            let permit = semaphore.clone().acquire_owned().await.unwrap();
-
-            counter("relay_https_connections_total").increment();
-            gauge("relay_https_connections_active").increment();
-
-            // Generate a correlation ID for this connection
-            let correlation_id = CorrelationId::new();
-            let correlation_id_for_span = correlation_id.clone();
-
-            tokio::spawn(
-                async move {
-                    debug!("New connection from {}", peer_addr);
-
-                    let start = std::time::Instant::now();
-                    let result = proxy
-                        .handle_connection(stream, peer_addr, correlation_id)
-                        .await;
-                    let duration = start.elapsed();
-
-                    histogram("relay_https_connection_duration_seconds")
-                        .observe(duration.as_secs_f64());
-                    gauge("relay_https_connections_active").decrement();
-
-                    if let Err(e) = result
-                        && !matches!(e, crate::common::error::TlsForwardError::Io(_))
-                    {
-                        warn!("Error handling connection from {}: {}", peer_addr, e);
-                        counter("relay_https_connection_errors").increment();
-                    }
-
-                    drop(permit);
-                }
-                .instrument(tracing::info_span!(
-                    "https_connection",
-                    %peer_addr,
-                    correlation_id = %correlation_id_for_span,
-                    otel.name = "relay_https_connection",
-                    otel.kind = "SERVER",
-                    trace_id = %correlation_id_for_span.trace_id(),
-                    span_id = %correlation_id_for_span.span_id(),
-                    traceparent = %correlation_id_for_span.to_traceparent()
-                )),
-            );
-        }
-    }
-
-    /// Handle a single HTTPS connection
-    #[instrument(
-        name = "handle_https_connection",
-        skip(self, stream),
-        fields(
-            peer_addr = %peer_addr,
-            hostname = tracing::field::Empty,
-            target_node = tracing::field::Empty,
-            correlation_id = %correlation_id
-        )
-    )]
-    async fn handle_connection(
-        &self,
-        mut stream: TcpStream,
-        peer_addr: SocketAddr,
-        correlation_id: CorrelationId,
-    ) -> Result<()> {
-        // Read enough data to extract SNI
-        let mut initial_data = vec![0u8; 1024]; // Usually enough for ClientHello
-        let n = timeout(
-            self.config.timeouts.sni_read,
-            stream.peek(&mut initial_data),
-        )
-        .await
-        .map_err(|_| crate::common::error::TlsForwardError::Timeout("SNI read timeout".into()))??;
-
-        initial_data.truncate(n);
-
-        // Extract SNI hostname
-        let hostname = extract_sni(&initial_data)?;
-        debug!("SNI hostname: {} from {}", hostname, peer_addr);
-        tracing::Span::current().record("hostname", &hostname);
-
-        // Look up target node in registry
-        let entry = self.registry.lookup(&hostname).await?;
-        debug!("Found node {} for domain {}", entry.node_id, hostname);
-        tracing::Span::current().record("target_node", entry.node_id.to_string());
-
-        counter("relay_https_proxy_requests_total").increment();
-
-        // Create new connection to target node
-        let p2p_connection = self
-            .endpoint
-            .connect(entry.node_id, TLS_FORWARD_ALPN)
-            .await
-            .map_err(crate::common::error::TlsForwardError::P2pConnect)?;
-
-        // Open bidirectional stream with timeout
-        let (send_stream, recv_stream) =
-            timeout(self.config.timeouts.connect, p2p_connection.open_bi())
-                .await
-                .map_err(|_| {
-                    crate::common::error::TlsForwardError::Timeout(
-                        "Failed to open P2P stream".into(),
-                    )
-                })??;
-        let mut p2p_stream = CombinedStream::new(recv_stream, send_stream);
-
-        info!("Proxying {} -> {} ({})", peer_addr, hostname, entry.node_id);
-
-        // Forward traffic bidirectionally with idle timeout
-        let result = timeout(
-            self.config.timeouts.idle,
-            StreamUtils::copy_bidirectional(&mut stream, &mut p2p_stream),
-        )
-        .await;
-
-        // Connection will be closed when it goes out of scope
-        match result {
-            Ok(Ok((client_to_p2p, p2p_to_client))) => {
-                debug!(
-                    "Connection closed: {} -> {} ({} bytes, {} bytes)",
-                    peer_addr, hostname, client_to_p2p, p2p_to_client
-                );
-                counter("relay_https_bytes_sent").add(p2p_to_client);
-                counter("relay_https_bytes_received").add(client_to_p2p);
-            }
-            Ok(Err(e)) => {
-                if !is_connection_closed_error(&e) {
-                    error!("Error copying data: {}", e);
-                    counter("relay_https_proxy_errors").increment();
-                }
-            }
-            Err(_) => {
-                warn!("Connection idle timeout: {} -> {}", peer_addr, hostname);
-                counter("relay_https_proxy_errors").increment();
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Gracefully shutdown the proxy
-    pub async fn shutdown(&self) -> Result<()> {
-        info!("Shutting down HTTPS proxy");
-        Ok(())
-    }
-}
-
-/// Check if an error is just a connection closed error
-fn is_connection_closed_error(e: &gate_p2p::stream::StreamError) -> bool {
-    if let gate_p2p::stream::StreamError::Io(io_err) = e {
-        matches!(
-            io_err.kind(),
-            std::io::ErrorKind::UnexpectedEof
-                | std::io::ErrorKind::ConnectionAborted
-                | std::io::ErrorKind::ConnectionReset
-                | std::io::ErrorKind::BrokenPipe
-        )
-    } else {
-        false
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_default_config() {
-        let config = HttpsProxyConfig::default();
-        assert_eq!(config.bind_addr.port(), 443);
-        assert_eq!(config.max_connections, 1000);
-    }
-}
diff --git a/crates/tlsforward/src/server/mod.rs b/crates/tlsforward/src/server/mod.rs
deleted file mode 100644
index 07b388de..00000000
--- a/crates/tlsforward/src/server/mod.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//! TLS forward server implementation
-
-pub mod config;
-pub mod dns;
-pub mod dns_challenge;
-pub mod http_handler;
-pub mod https_proxy;
-pub mod registry;
-pub mod router;
-pub mod sni;
-pub mod state_dir;
-
-// Re-export main server components
-pub use config::TlsForwardConfig;
-pub use https_proxy::{HttpsProxy, HttpsProxyConfig};
-pub use registry::{ProxyRegistry, RegistryEntry};
-
-#[cfg(test)]
-mod dns_challenge_tests;
-#[cfg(test)]
-mod router_tests;
diff --git a/crates/tlsforward/src/server/registry.rs b/crates/tlsforward/src/server/registry.rs
deleted file mode 100644
index 5db0c3f1..00000000
--- a/crates/tlsforward/src/server/registry.rs
+++ /dev/null
@@ -1,211 +0,0 @@
-//! Registry for mapping domains to P2P node addresses
-
-use crate::common::error::{Result, TlsForwardError};
-use gate_core::tracing::metrics::gauge;
-use iroh::NodeId;
-use std::collections::HashMap;
-use std::sync::Arc;
-use std::time::Instant;
-use tokio::sync::RwLock;
-
-/// Entry in the proxy registry
-#[derive(Debug, Clone)]
-pub struct RegistryEntry {
-    /// Full node ID
-    pub node_id: NodeId,
-    /// Optional metadata
-    pub metadata: HashMap<String, String>,
-    /// When the node connected
-    pub connected_at: Instant,
-    /// Last ping timestamp
-    pub last_ping: Instant,
-    /// Latest measured latency in milliseconds
-    pub latency_ms: Option<u64>,
-}
-
-/// Registry for mapping short domain hashes to node information
-#[derive(Clone)]
-pub struct ProxyRegistry {
-    /// Internal storage for mappings
-    /// Key: short hash (first 16 chars of node ID hex)
-    /// Value: registry entry
-    entries: Arc<RwLock<HashMap<String, RegistryEntry>>>,
-    /// Domain suffix (e.g., "private.hellas.ai")
-    domain_suffix: String,
-}
-
-impl ProxyRegistry {
-    /// Create a new proxy registry
-    pub fn new(domain_suffix: String) -> Self {
-        Self {
-            entries: Arc::new(RwLock::new(HashMap::new())),
-            domain_suffix,
-        }
-    }
-
-    /// Register a node with its address
-    pub async fn register(&self, node_id: NodeId) -> Result<String> {
-        let short_hash = node_id.fmt_short();
-        let now = Instant::now();
-        let entry = RegistryEntry {
-            node_id,
-            metadata: HashMap::new(),
-            connected_at: now,
-            last_ping: now,
-            latency_ms: None,
-        };
-
-        let mut entries = self.entries.write().await;
-        entries.insert(short_hash.clone(), entry);
-        gauge("relay_registry_nodes").set(entries.len() as i64);
-
-        Ok(format!("{}.{}", short_hash, self.domain_suffix))
-    }
-
-    /// Unregister a node
-    pub async fn unregister(&self, node_id: &NodeId) -> Result<()> {
-        let short_hash = node_id.fmt_short();
-        let mut entries = self.entries.write().await;
-        entries.remove(&short_hash);
-        gauge("relay_registry_nodes").set(entries.len() as i64);
-        Ok(())
-    }
-
-    /// Look up a node by domain name
-    pub async fn lookup(&self, domain: &str) -> Result<RegistryEntry> {
-        // Extract short hash from domain
-        let short_hash = self.extract_short_hash(domain)?;
-
-        let entries = self.entries.read().await;
-        debug!(
-            "Looking up domain {} (short_hash: {}), registry has {} entries",
-            domain,
-            short_hash,
-            entries.len()
-        );
-        entries.get(&short_hash).cloned().ok_or_else(|| {
-            debug!("Node not found for short_hash: {}", short_hash);
-            TlsForwardError::NodeNotFound(domain.to_string())
-        })
-    }
-
-    /// Look up a node by short hash directly
-    pub async fn lookup_by_hash(&self, short_hash: &str) -> Result<RegistryEntry> {
-        let entries = self.entries.read().await;
-        entries
-            .get(short_hash)
-            .cloned()
-            .ok_or_else(|| TlsForwardError::NodeNotFound(short_hash.to_string()))
-    }
-
-    /// Get all registered nodes
-    pub async fn list_all(&self) -> Vec<(String, RegistryEntry)> {
-        let entries = self.entries.read().await;
-        entries
-            .iter()
-            .map(|(k, v)| (k.clone(), v.clone()))
-            .collect()
-    }
-
-    /// Update ping information for a node
-    pub async fn update_ping(&self, node_id: &NodeId, latency_ms: Option<u64>) -> Result<()> {
-        let short_hash = node_id.fmt_short();
-        let mut entries = self.entries.write().await;
-
-        debug!(
-            "Updating ping for node {} (short_hash: {}), registry has {} entries",
-            node_id,
-            short_hash,
-            entries.len()
-        );
-
-        if let Some(entry) = entries.get_mut(&short_hash) {
-            entry.last_ping = Instant::now();
-            if let Some(latency) = latency_ms {
-                entry.latency_ms = Some(latency);
-            }
-            debug!("Successfully updated ping for node {}", node_id);
-            Ok(())
-        } else {
-            debug!(
-                "Failed to update ping - node {} (short_hash: {}) not found in registry",
-                node_id, short_hash
-            );
-            Err(TlsForwardError::NodeNotFound(short_hash))
-        }
-    }
-
-    /// Extract short hash from a full domain name
-    fn extract_short_hash(&self, domain: &str) -> Result<String> {
-        // Remove the domain suffix if present
-        let domain = domain.trim_end_matches('.');
-        let suffix = format!(".{}", self.domain_suffix);
-
-        if let Some(prefix) = domain.strip_suffix(&suffix) {
-            // Validate the short hash format (10 hex chars from fmt_short)
-            if prefix.len() == 10 && prefix.chars().all(|c| c.is_ascii_hexdigit()) {
-                Ok(prefix.to_string())
-            } else {
-                Err(TlsForwardError::InvalidSni(format!(
-                    "Invalid short hash in domain: {domain}"
-                )))
-            }
-        } else {
-            Err(TlsForwardError::InvalidSni(format!(
-                "Domain {} does not match suffix {}",
-                domain, self.domain_suffix
-            )))
-        }
-    }
-
-    /// Look up a node by its ID
-    pub async fn lookup_by_node_id(&self, node_id: &NodeId) -> Result<RegistryEntry> {
-        let short_hash = node_id.fmt_short();
-        self.lookup_by_hash(&short_hash).await
-    }
-
-    /// Clear all entries
-    pub async fn clear(&self) {
-        let mut entries = self.entries.write().await;
-        entries.clear();
-    }
-
-    /// Get the number of registered nodes
-    pub async fn len(&self) -> usize {
-        let entries = self.entries.read().await;
-        entries.len()
-    }
-
-    /// Check if the registry is empty
-    pub async fn is_empty(&self) -> bool {
-        let entries = self.entries.read().await;
-        entries.is_empty()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_short_hash_extraction() {
-        let registry = ProxyRegistry::new("private.hellas.ai".to_string());
-
-        // Test domain parsing (10 hex chars)
-        assert!(
-            registry
-                .extract_short_hash("1234567890.private.hellas.ai")
-                .is_ok()
-        );
-        assert!(
-            registry
-                .extract_short_hash("invalid.private.hellas.ai")
-                .is_err()
-        );
-        assert!(
-            registry
-                .extract_short_hash("1234567890.wrong.domain")
-                .is_err()
-        );
-    }
-}
diff --git a/crates/tlsforward/src/server/router.rs b/crates/tlsforward/src/server/router.rs
deleted file mode 100644
index 7901606a..00000000
--- a/crates/tlsforward/src/server/router.rs
+++ /dev/null
@@ -1,339 +0,0 @@
-//! HTTP API router for relay control and DNS challenge management
-
-use axum::{
-    Router,
-    extract::{Extension, Path, State},
-    http::StatusCode,
-    response::{IntoResponse, Json},
-    routing::{delete, get, post},
-};
-use chrono::{DateTime, Utc};
-use std::sync::Arc;
-use std::time::{SystemTime, UNIX_EPOCH};
-
-use super::dns_challenge::{DnsChallenge, DnsChallengeManager};
-use super::registry::ProxyRegistry;
-use crate::common::{types::TlsForwardInfo, *};
-use iroh::NodeId;
-
-/// API state combining DNS manager and proxy registry
-#[derive(Clone)]
-pub struct ApiState {
-    pub dns_manager: Arc<DnsChallengeManager>,
-    pub registry: Arc<ProxyRegistry>,
-    pub domain_suffix: String,
-    /// The TLS forward server's own node ID
-    pub tlsforward_node_id: NodeId,
-    ///// The TLS forward server's own node address
-    // pub tlsforward_node_addr: iroh::NodeAddr,
-}
-
-/// Create the router for TLS forward APIs
-pub fn create_api_router() -> Router<ApiState> {
-    Router::new()
-        // ACME endpoints
-        .route("/acme/challenge", post(create_challenge))
-        .route("/acme/challenge/{id}/status", get(get_challenge_status))
-        .route("/acme/challenge/{id}", delete(delete_challenge))
-        // TLS forward control endpoints
-        .route("/register", post(handle_register))
-        .route("/unregister", delete(handle_unregister))
-        .route("/status", get(handle_status))
-        .route("/ping", post(handle_ping))
-        .route("/nodes", get(list_nodes))
-}
-
-/// Create a new DNS challenge
-#[instrument(
-    name = "create_dns_challenge",
-    skip(state),
-    fields(
-        node_id = %node_id,
-        domain = %req.domain,
-        challenge_type = %req.challenge
-    )
-)]
-async fn create_challenge(
-    State(state): State<ApiState>,
-    Extension(node_id): Extension<NodeId>,
-    Json(req): Json<CreateChallengeRequest>,
-) -> impl IntoResponse {
-    let manager = &state.dns_manager;
-    info!(
-        "Creating DNS challenge for domain: {} with value: {} from node: {}",
-        req.domain, req.value, node_id
-    );
-    debug!(
-        "Challenge request details - domain: {}, challenge: {}, value: {}",
-        req.domain, req.challenge, req.value
-    );
-
-    // Validate domain format (should match our pattern)
-    if !manager.validate_domain(&req.domain) {
-        error!("Invalid domain format: {}", req.domain);
-        return (
-            StatusCode::BAD_REQUEST,
-            Json(ErrorResponse::new(
-                "INVALID_DOMAIN",
-                format!("Invalid domain format: {}", req.domain),
-            )),
-        )
-            .into_response();
-    }
-
-    // Verify that the requesting node owns this domain
-    let expected_short_hash = node_id.fmt_short();
-    let domain_prefix = req.domain.split('.').next().unwrap_or("");
-
-    if domain_prefix != expected_short_hash {
-        error!(
-            "Node {} attempted to create challenge for domain {} which it doesn't own",
-            node_id, req.domain
-        );
-        return (
-            StatusCode::FORBIDDEN,
-            Json(ErrorResponse::new(
-                "DOMAIN_NOT_OWNED",
-                "You can only create challenges for domains assigned to your node",
-            )),
-        )
-            .into_response();
-    }
-
-    // Create the challenge
-    let challenge = DnsChallenge {
-        domain: req.domain,
-        challenge: req.challenge,
-        value: req.value,
-    };
-
-    match manager.create_challenge(challenge, node_id).await {
-        Ok(id) => {
-            info!("DNS challenge created successfully with ID: {}", id);
-            (
-                StatusCode::OK,
-                Json(CreateChallengeResponse {
-                    id,
-                    status: ChallengeStatus::Pending,
-                }),
-            )
-                .into_response()
-        }
-        Err(e) => {
-            error!("Failed to create DNS challenge: {}", e);
-            (
-                StatusCode::INTERNAL_SERVER_ERROR,
-                Json(ErrorResponse::new(
-                    "DNS_CHALLENGE_FAILED",
-                    format!("Failed to create DNS challenge: {e}"),
-                )),
-            )
-                .into_response()
-        }
-    }
-}
-
-/// Get the status of a DNS challenge
-async fn get_challenge_status(
-    State(state): State<ApiState>,
-    Extension(node_id): Extension<NodeId>,
-    Path(id): Path<String>,
-) -> impl IntoResponse {
-    debug!("Checking status for challenge: {}", id);
-
-    match state.dns_manager.get_challenge_status(&id, &node_id).await {
-        Ok((status, checks)) => (
-            StatusCode::OK,
-            Json(ChallengeStatusResponse { id, status, checks }),
-        )
-            .into_response(),
-        Err(e) => {
-            error!("Failed to get challenge status: {}", e);
-            (
-                StatusCode::NOT_FOUND,
-                Json(ErrorResponse::new(
-                    "CHALLENGE_NOT_FOUND",
-                    format!("Challenge not found: {id}"),
-                )),
-            )
-                .into_response()
-        }
-    }
-}
-
-/// Delete a DNS challenge
-async fn delete_challenge(
-    State(state): State<ApiState>,
-    Extension(node_id): Extension<NodeId>,
-    Path(id): Path<String>,
-) -> impl IntoResponse {
-    let manager = &state.dns_manager;
-    info!("Deleting challenge: {}", id);
-
-    match manager.delete_challenge(&id, &node_id).await {
-        Ok(_) => (
-            StatusCode::OK,
-            Json(DeleteChallengeResponse {
-                id,
-                status: "deleted".to_string(),
-            }),
-        )
-            .into_response(),
-        Err(e) => {
-            error!("Failed to delete challenge: {}", e);
-            (
-                StatusCode::NOT_FOUND,
-                Json(ErrorResponse::new(
-                    "CHALLENGE_NOT_FOUND",
-                    format!("Challenge not found: {id}"),
-                )),
-            )
-                .into_response()
-        }
-    }
-}
-
-// Relay control handlers
-
-/// Handle registration request
-async fn handle_register(
-    State(state): State<ApiState>,
-    Extension(node_id): Extension<NodeId>,
-    _: Json<RegistrationRequest>,
-) -> impl IntoResponse {
-    // Generate domain
-    let domain = format!("{}.{}", node_id.fmt_short(), state.domain_suffix);
-
-    match state.registry.register(node_id).await {
-        Ok(_) => {
-            info!("Registered node {} with domain {}", node_id, domain);
-            debug!(
-                "Registry now contains {} nodes",
-                state.registry.list_all().await.len()
-            );
-
-            // Build TLS forward info with the TLS forward server's information
-            let tlsforward_info = TlsForwardInfo {
-                node_id: state.tlsforward_node_id,
-                domain_suffix: state.domain_suffix.clone(),
-            };
-
-            (
-                StatusCode::OK,
-                Json(RegistrationResponse {
-                    domain,
-                    tlsforward_info,
-                }),
-            )
-                .into_response()
-        }
-        Err(e) => {
-            error!("Failed to register node {}: {}", node_id, e);
-            (
-                StatusCode::INTERNAL_SERVER_ERROR,
-                Json(ErrorResponse::new(
-                    "REGISTRATION_FAILED",
-                    format!("Failed to register node: {e}"),
-                )),
-            )
-                .into_response()
-        }
-    }
-}
-
-/// Handle unregister request
-async fn handle_unregister(
-    State(state): State<ApiState>,
-    Extension(node_id): Extension<NodeId>,
-) -> StatusCode {
-    match state.registry.unregister(&node_id).await {
-        Ok(_) => {
-            info!("Unregistered node {}", node_id);
-            StatusCode::OK
-        }
-        Err(e) => {
-            error!("Failed to unregister node {}: {}", node_id, e);
-            StatusCode::NOT_FOUND
-        }
-    }
-}
-
-/// Handle status request
-async fn handle_status(
-    State(state): State<ApiState>,
-    Extension(node_id): Extension<NodeId>,
-) -> Json<StatusResponse> {
-    let is_registered = state.registry.lookup_by_node_id(&node_id).await.is_ok();
-
-    let domain = if is_registered {
-        Some(format!("{}.{}", node_id.fmt_short(), state.domain_suffix))
-    } else {
-        None
-    };
-
-    Json(StatusResponse {
-        registered: is_registered,
-        domain,
-        active_connections: 0, // TODO: Track this
-        uptime_seconds: 0,     // TODO: Track this
-    })
-}
-
-/// Handle ping request
-#[instrument(name = "handle_ping", skip_all)]
-async fn handle_ping(
-    State(state): State<ApiState>,
-    Extension(node_id): Extension<NodeId>,
-) -> impl IntoResponse {
-    // Update ping information for the node
-    match state.registry.update_ping(&node_id, None).await {
-        Ok(_) => {
-            debug!("Updated ping for node {}", node_id);
-        }
-        Err(e) => {
-            // If node is not registered, this is not an error - just log at debug level
-            // Nodes may ping before registering
-            debug!("Node {} not registered yet, ignoring ping: {}", node_id, e);
-        }
-    }
-
-    Json(EmptyResponse {})
-}
-
-/// List all connected nodes
-#[instrument(name = "list_nodes", skip_all)]
-async fn list_nodes(State(state): State<ApiState>) -> Json<ListNodesResponse> {
-    let all_nodes = state.registry.list_all().await;
-    let mut nodes = Vec::with_capacity(all_nodes.len());
-
-    for (short_hash, entry) in all_nodes {
-        let domain = format!("{}.{}", short_hash, state.domain_suffix);
-
-        // Calculate uptime
-        let uptime_seconds = entry.connected_at.elapsed().as_secs();
-
-        // Convert Instant to SystemTime for ISO 8601 formatting
-        let connected_at = SystemTime::now()
-            .checked_sub(entry.connected_at.elapsed())
-            .unwrap_or(UNIX_EPOCH);
-        let connected_at_dt: DateTime<Utc> = connected_at.into();
-
-        let last_ping = SystemTime::now()
-            .checked_sub(entry.last_ping.elapsed())
-            .unwrap_or(UNIX_EPOCH);
-        let last_ping_dt: DateTime<Utc> = last_ping.into();
-
-        nodes.push(ConnectedNode {
-            node_id: entry.node_id.to_string(),
-            domain,
-            connected_at: connected_at_dt.to_rfc3339(),
-            uptime_seconds,
-            latency_ms: entry.latency_ms,
-            last_ping: last_ping_dt.to_rfc3339(),
-        });
-    }
-
-    let total = nodes.len();
-
-    Json(ListNodesResponse { nodes, total })
-}
diff --git a/crates/tlsforward/src/server/router_tests.rs b/crates/tlsforward/src/server/router_tests.rs
deleted file mode 100644
index 2a7fd0d3..00000000
--- a/crates/tlsforward/src/server/router_tests.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-//! Tests for router security and domain ownership validation
-
-#[cfg(test)]
-mod tests {
-    use crate::common::CreateChallengeRequest;
-    use iroh::{NodeId, SecretKey};
-
-    // Helper to create a test node ID
-    fn test_node_id(seed: u8) -> NodeId {
-        let key_bytes = [seed; 32];
-        let secret_key = SecretKey::from_bytes(&key_bytes);
-        secret_key.public()
-    }
-
-    #[tokio::test]
-    async fn test_create_challenge_domain_ownership() {
-        // Create a node and get its short hash
-        let node_id = test_node_id(1);
-        let short_hash = node_id.fmt_short();
-
-        // Test 1: Node can create challenge for its own domain
-        let _valid_request = CreateChallengeRequest {
-            domain: format!("{short_hash}.private.hellas.ai"),
-            challenge: "_acme-challenge".to_string(),
-            value: "test-value-123".to_string(),
-        };
-
-        // Test 2: Node cannot create challenge for another domain
-        let _invalid_request = CreateChallengeRequest {
-            domain: "different1234567.private.hellas.ai".to_string(),
-            challenge: "_acme-challenge".to_string(),
-            value: "test-value-123".to_string(),
-        };
-
-        // In a real test, we would set up the router and test the actual endpoints
-        // but that requires more infrastructure setup
-    }
-
-    #[test]
-    fn test_node_id_fmt_short_consistency() {
-        let node_id = test_node_id(42);
-        let hash1 = node_id.fmt_short();
-        let hash2 = node_id.fmt_short();
-
-        assert_eq!(hash1, hash2, "Hash should be consistent");
-        assert_eq!(hash1.len(), 10, "Short hash should be 10 chars");
-        assert!(
-            hash1.chars().all(|c| c.is_ascii_hexdigit()),
-            "Hash should be hex"
-        );
-    }
-
-    #[test]
-    fn test_domain_extraction() {
-        let test_cases = vec![
-            ("abcd1234ab.private.hellas.ai", Some("abcd1234ab")),
-            ("test.private.hellas.ai", Some("test")),
-            ("sub.domain.private.hellas.ai", Some("sub")),
-            ("nodomain", Some("nodomain")),
-            ("", Some("")),
-        ];
-
-        for (domain, expected) in test_cases {
-            let prefix = domain.split('.').next();
-            assert_eq!(prefix, expected, "Failed for domain: {domain}");
-        }
-    }
-}
diff --git a/crates/tlsforward/src/server/sni.rs b/crates/tlsforward/src/server/sni.rs
deleted file mode 100644
index 8e8960ed..00000000
--- a/crates/tlsforward/src/server/sni.rs
+++ /dev/null
@@ -1,166 +0,0 @@
-//! SNI (Server Name Indication) extraction from TLS ClientHello
-
-use crate::common::error::{Result, TlsForwardError};
-use bytes::Buf;
-use std::io::Cursor;
-
-/// Extract the SNI hostname from a TLS ClientHello message
-pub fn extract_sni(data: &[u8]) -> Result<String> {
-    let mut cursor = Cursor::new(data);
-
-    // Check minimum size for TLS record header
-    if data.len() < 5 {
-        return Err(TlsForwardError::InvalidSni(
-            "Data too short for TLS record".into(),
-        ));
-    }
-
-    // Read TLS record header
-    let content_type = cursor.get_u8();
-    let version_major = cursor.get_u8();
-    let version_minor = cursor.get_u8();
-    let record_length = cursor.get_u16();
-
-    // Validate TLS handshake record (content_type = 22)
-    if content_type != 22 {
-        return Err(TlsForwardError::InvalidSni(format!(
-            "Not a handshake record: content_type = {content_type}"
-        )));
-    }
-
-    // Validate TLS version (TLS 1.0-1.3)
-    if version_major != 3 || version_minor > 4 {
-        return Err(TlsForwardError::InvalidSni(format!(
-            "Invalid TLS version: {version_major}.{version_minor}"
-        )));
-    }
-
-    // Check if we have enough data for the record
-    if cursor.remaining() < record_length as usize {
-        return Err(TlsForwardError::InvalidSni("Incomplete TLS record".into()));
-    }
-
-    // Read handshake header
-    if cursor.remaining() < 4 {
-        return Err(TlsForwardError::InvalidSni("No handshake header".into()));
-    }
-
-    let handshake_type = cursor.get_u8();
-    let handshake_length = cursor.get_uint(3) as usize;
-
-    // Validate ClientHello (handshake_type = 1)
-    if handshake_type != 1 {
-        return Err(TlsForwardError::InvalidSni(format!(
-            "Not a ClientHello: handshake_type = {handshake_type}"
-        )));
-    }
-
-    // Check handshake message length
-    if cursor.remaining() < handshake_length {
-        return Err(TlsForwardError::InvalidSni(
-            "Incomplete handshake message".into(),
-        ));
-    }
-
-    // Skip client version (2 bytes)
-    cursor.advance(2);
-
-    // Skip random (32 bytes)
-    cursor.advance(32);
-
-    // Skip session ID
-    let session_id_len = cursor.get_u8() as usize;
-    cursor.advance(session_id_len);
-
-    // Skip cipher suites
-    let cipher_suites_len = cursor.get_u16() as usize;
-    cursor.advance(cipher_suites_len);
-
-    // Skip compression methods
-    let compression_methods_len = cursor.get_u8() as usize;
-    cursor.advance(compression_methods_len);
-
-    // Check if extensions are present
-    if cursor.remaining() < 2 {
-        return Err(TlsForwardError::InvalidSni("No extensions present".into()));
-    }
-
-    let extensions_len = cursor.get_u16() as usize;
-    if cursor.remaining() < extensions_len {
-        return Err(TlsForwardError::InvalidSni("Incomplete extensions".into()));
-    }
-
-    let extensions_end = cursor.position() + extensions_len as u64;
-
-    // Parse extensions
-    while cursor.position() < extensions_end {
-        if cursor.remaining() < 4 {
-            break;
-        }
-
-        let extension_type = cursor.get_u16();
-        let extension_len = cursor.get_u16() as usize;
-
-        if cursor.remaining() < extension_len {
-            return Err(TlsForwardError::InvalidSni("Incomplete extension".into()));
-        }
-
-        // Server Name extension (type = 0)
-        if extension_type == 0 {
-            return parse_sni_extension(&mut cursor, extension_len);
-        }
-
-        // Skip this extension
-        cursor.advance(extension_len);
-    }
-
-    Err(TlsForwardError::InvalidSni("No SNI extension found".into()))
-}
-
-/// Parse the SNI extension to extract the hostname
-fn parse_sni_extension(cursor: &mut Cursor<&[u8]>, extension_len: usize) -> Result<String> {
-    let start_pos = cursor.position();
-
-    // Read server name list length
-    if cursor.remaining() < 2 {
-        return Err(TlsForwardError::InvalidSni("Invalid SNI extension".into()));
-    }
-    let _list_len = cursor.get_u16() as usize;
-
-    // Parse server names
-    while cursor.position() < start_pos + extension_len as u64 {
-        if cursor.remaining() < 3 {
-            break;
-        }
-
-        let name_type = cursor.get_u8();
-        let name_len = cursor.get_u16() as usize;
-
-        if cursor.remaining() < name_len {
-            return Err(TlsForwardError::InvalidSni("Incomplete server name".into()));
-        }
-
-        // Host name type (0)
-        if name_type == 0 {
-            let mut hostname_bytes = vec![0u8; name_len];
-            cursor.copy_to_slice(&mut hostname_bytes);
-
-            let hostname = String::from_utf8(hostname_bytes)
-                .map_err(|_| TlsForwardError::InvalidSni("Invalid UTF-8 in hostname".into()))?;
-
-            // Basic validation
-            if hostname.is_empty() {
-                return Err(TlsForwardError::InvalidSni("Empty hostname".into()));
-            }
-
-            return Ok(hostname);
-        }
-
-        // Skip other name types
-        cursor.advance(name_len);
-    }
-
-    Err(TlsForwardError::InvalidSni(
-        "No hostname in SNI extension".into(),
-    ))
-}
diff --git a/crates/tlsforward/src/server/state_dir.rs b/crates/tlsforward/src/server/state_dir.rs
deleted file mode 100644
index e690a6fe..00000000
--- a/crates/tlsforward/src/server/state_dir.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-//! Platform-specific state directory management for TLS forward server
-
-use anyhow::{Context, Result};
-use directories::ProjectDirs;
-use std::path::PathBuf;
-
-/// Manages platform-specific application directories for the TLS forward server
-pub struct TlsForwardStateDir {
-    /// Project directories from the directories crate
-    project_dirs: Option<ProjectDirs>,
-    /// Override directory for testing or custom installations
-    override_dir: Option<PathBuf>,
-}
-
-impl TlsForwardStateDir {
-    /// Create a new TlsForwardStateDir instance
-    pub fn new() -> Self {
-        let project_dirs = ProjectDirs::from("com.hellas", "Gate", "Gate-TlsForward");
-
-        if project_dirs.is_none() {
-            warn!("Failed to determine platform-specific directories, will use fallback");
-        }
-
-        Self {
-            project_dirs,
-            override_dir: None,
-        }
-    }
-
-    /// Create a new TlsForwardStateDir with an override directory
-    pub fn with_override(path: impl Into<PathBuf>) -> Self {
-        Self {
-            project_dirs: None,
-            override_dir: Some(path.into()),
-        }
-    }
-
-    /// Get the configuration directory
-    pub fn config_dir(&self) -> PathBuf {
-        if let Some(override_dir) = &self.override_dir {
-            return override_dir.join("config");
-        }
-
-        if let Some(project_dirs) = &self.project_dirs {
-            project_dirs.config_dir().to_path_buf()
-        } else {
-            // Fallback to current directory
-            PathBuf::from("./config")
-        }
-    }
-
-    /// Get the data directory for persistent storage
-    pub fn data_dir(&self) -> PathBuf {
-        if let Some(override_dir) = &self.override_dir {
-            return override_dir.join("data");
-        }
-
-        if let Some(project_dirs) = &self.project_dirs {
-            project_dirs.data_dir().to_path_buf()
-        } else {
-            // Fallback to current directory
-            PathBuf::from("./data")
-        }
-    }
-
-    /// Get the directory for storing keys
-    pub fn keys_dir(&self) -> PathBuf {
-        self.data_dir().join("keys")
-    }
-
-    /// Get the path for the relay secret key
-    pub fn secret_key_path(&self) -> PathBuf {
-        self.keys_dir().join("secret.key")
-    }
-
-    /// Create all required directories
-    pub async fn create_directories(&self) -> Result<()> {
-        let dirs = vec![self.config_dir(), self.data_dir(), self.keys_dir()];
-
-        for dir in dirs {
-            tokio::fs::create_dir_all(&dir)
-                .await
-                .with_context(|| format!("Failed to create directory: {}", dir.display()))?;
-            debug!("Ensured directory exists: {}", dir.display());
-        }
-
-        info!("Created relay state directories:");
-        info!("  Config: {}", self.config_dir().display());
-        info!("  Data: {}", self.data_dir().display());
-
-        Ok(())
-    }
-}
-
-impl Default for TlsForwardStateDir {
-    fn default() -> Self {
-        Self::new()
-    }
-}
diff --git a/docs/SIGNING.md b/docs/SIGNING.md
index bd493848..65b71238 100644
--- a/docs/SIGNING.md
+++ b/docs/SIGNING.md
@@ -1,70 +1,41 @@
-# macOS Code Signing Setup
+# macOS signing and App Attest
 
-This document explains how to set up code signing for macOS binaries in GitHub Actions.
+Gate's App Attest producer is intentionally owned by the signed application,
+not by `hellas-attestation` or `hellas-cli`.
 
-## Required GitHub Secrets
+The default Tauri build deliberately has no restricted App Attest entitlement.
+It is the normal, launchable desktop app and reports App Attest as unavailable.
+It may be signed with Developer ID in the usual way without a provisioning
+profile.
 
-You need to add the following secrets to your GitHub repository:
+For the attested provider to start, a provisioned build must use:
 
-### 1. `APPLE_CERTIFICATE`
-Your Apple Developer ID Application certificate in base64 format.
+- bundle identifier `ai.hellas.gate`;
+- an Apple provisioning profile whose App ID matches that identifier; and
+- the `com.apple.developer.devicecheck.app-attest-opt-in` entitlement with the
+  value `CDhash` in that profile.
 
-To export your certificate:
-1. Open Keychain Access on macOS
-2. Find your "Developer ID Application" certificate
-3. Right-click and select "Export..."
-4. Save as a .p12 file with a password
-5. Convert to base64: `base64 -i certificate.p12 | pbcopy`
-6. Add the base64 string as a GitHub secret
+Build the app ad-hoc first, then embed the provisioning profile and apply the
+final Developer ID signature in one validated step:
 
-### 2. `APPLE_CERTIFICATE_PASSWORD`
-The password you used when exporting the .p12 certificate.
-
-### 3. `KEYCHAIN_PASSWORD`
-A password for the temporary keychain created during CI. Can be any secure string.
-
-### 4. `APPLE_SIGNING_IDENTITY`
-Your signing identity, typically in the format: "Developer ID Application: Your Name (TEAMID)"
-
-To find your signing identity:
-```bash
-security find-identity -v -p codesigning
+```sh
+APPLE_SIGNING_IDENTITY=- cargo tauri build
+./macos/sign.sh path/to/gate.provisionprofile \
+  /tmp/hellas-gate-target/release/bundle/macos/Hellas\ Gate.app
 ```
 
-### 5. `APPLE_ID`
-Your Apple ID email address used for developer account.
-
-### 6. `APPLE_PASSWORD`
-An app-specific password for notarization.
-
-To create an app-specific password:
-1. Go to https://appleid.apple.com/account/manage
-2. Sign in with your Apple ID
-3. In the "Sign-In and Security" section, select "App-Specific Passwords"
-4. Click the plus button to generate a new password
-5. Name it something like "GitHub Actions Notarization"
-6. Copy the generated password
-
-### 7. `APPLE_TEAM_ID`
-Your Apple Developer Team ID (10-character string).
-
-You can find this in:
-- Apple Developer portal under Membership
-- Or in your signing identity (the part in parentheses)
-
-## Adding Secrets to GitHub
-
-1. Go to your repository on GitHub
-2. Click Settings → Secrets and variables → Actions
-3. Click "New repository secret" for each secret above
-4. Enter the name and value for each secret
-
-## Testing
-
-After setting up the secrets, your CI will:
-1. Import the certificate into a temporary keychain
-2. Sign the app during the Tauri build process
-3. Notarize the DMG file with Apple
-4. Staple the notarization ticket to the DMG
-
-The signed and notarized app will run on any macOS system without security warnings.
\ No newline at end of file
+`macos/sign.sh` embeds the profile and signs with the entitlements extracted
+from it. It rejects a profile whose application identifier does not match the
+app bundle identifier and rejects entitlements that relax hardened runtime or
+library validation. Set `SIGN_IDENTITY` only when more than one Developer ID
+Application identity is installed. Do not add the restricted entitlement to
+the default Tauri configuration: macOS refuses to launch such a bundle when it
+lacks a matching profile.
+
+Gate checks `DCAppAttestService` at runtime and reports unavailable when Apple
+rejects the build or machine. It does not fall back to a software root.
+
+App Attest keys are created and retained by Apple's service. Gate persists only
+the opaque key identifier and the canonical Hellas enrollment bundle in its
+private application data directory. A persisted enrollment is fully verified
+against the current Gate transport/caller identity before it is reused.
diff --git a/docs/WINDOWS_SETUP_GUIDE.md b/docs/WINDOWS_SETUP_GUIDE.md
deleted file mode 100644
index 591a0e9a..00000000
--- a/docs/WINDOWS_SETUP_GUIDE.md
+++ /dev/null
@@ -1,290 +0,0 @@
-# Windows Setup Guide for Gate
-
-This guide provides step-by-step instructions for setting up the Gate development environment on Windows.
-
-## Prerequisites
-
-### Required Software
-
-1. **Visual Studio Build Tools 2022** (or Visual Studio Community/Professional)
-   - Download from: https://visualstudio.microsoft.com/downloads/
-   - Required workloads:
-     - C++ build tools
-     - Windows 10/11 SDK (latest version)
-     - MSVC v143 - VS 2022 C++ x64/x86 build tools
-
-2. **Git for Windows**
-   - Download from: https://git-scm.com/download/win
-   - Ensure "Git Bash" is included in the installation
-
-3. **vcpkg** (for OpenSSL dependencies)
-   - Clone vcpkg: `git clone https://github.com/Microsoft/vcpkg.git`
-   - Run: `.\vcpkg\bootstrap-vcpkg.bat`
-   - Add vcpkg to your PATH or note its location
-
-### Rust Installation
-
-1. **Install Rust via rustup**
-   ```powershell
-   # Download and run rustup-init.exe from https://rustup.rs/
-   # Or use PowerShell:
-   Invoke-WebRequest -Uri "https://win.rustup.rs/x86_64" -OutFile "rustup-init.exe"
-   .\rustup-init.exe
-   ```
-
-2. **Verify Rust installation**
-   ```powershell
-   rustc --version
-   cargo --version
-   ```
-
-3. **Install the specific nightly toolchain**
-   ```powershell
-   rustup install nightly-2025-06-10
-   rustup default nightly-2025-06-10
-   ```
-
-4. **Add required components and targets**
-   ```powershell
-   rustup component add rustfmt clippy rust-src rust-analyzer
-   rustup target add wasm32-unknown-unknown
-   rustup target add x86_64-pc-windows-msvc
-   ```
-
-### Build Tools
-
-1. **Install Trunk (WASM build tool)**
-   ```powershell
-   cargo install trunk --locked
-   ```
-
-2. **Install Tauri CLI**
-   ```powershell
-   cargo install tauri-cli --locked
-   ```
-
-3. **Install TailwindCSS standalone**
-   ```powershell
-   # Create a directory for tools (e.g., C:\tools)
-   mkdir C:\tools
-   
-   # Download TailwindCSS for Windows
-   Invoke-WebRequest -Uri "https://github.com/tailwindlabs/tailwindcss/releases/download/v4.1.11/tailwindcss-windows-x64.exe" -OutFile "C:\tools\tailwindcss.exe"
-   
-   # Add C:\tools to your PATH environment variable
-   ```
-
-### OpenSSL Dependencies
-
-Gate requires OpenSSL libraries for Windows. Install them using vcpkg:
-
-```powershell
-# Navigate to your vcpkg directory
-cd C:\path\to\vcpkg
-
-# Install OpenSSL for both static and dynamic linking
-.\vcpkg install openssl:x64-windows-static
-.\vcpkg install openssl:x64-windows-static-md
-
-# Integrate vcpkg with your development environment
-.\vcpkg integrate install
-```
-
-### Environment Variables
-
-Set the following environment variables (add to System Properties → Environment Variables):
-
-```
-VCPKG_ROOT=C:\path\to\vcpkg
-OPENSSL_DIR=%VCPKG_ROOT%\installed\x64-windows-static
-PKG_CONFIG_PATH=%VCPKG_ROOT%\installed\x64-windows-static\lib\pkgconfig
-```
-
-## Project Setup
-
-1. **Clone the repository**
-   ```powershell
-   git clone https://github.com/hellas-ai/gate.git
-   cd gate
-   ```
-
-2. **Verify toolchain**
-   ```powershell
-   # This should show nightly-2025-06-10
-   rustup show
-   ```
-
-3. **Build the project**
-   ```powershell
-   # Quick development build
-   cargo build
-
-   # Or full release build
-   cargo build --release --all
-   ```
-
-## Build Commands
-
-### Core Build Commands
-
-```powershell
-# Development build
-cargo build --all
-
-# Release build
-cargo build --release --all
-
-# Run tests
-cargo test --all --all-features
-
-# Format code
-cargo fmt --all
-
-# Lint with clippy
-cargo clippy --all-features -- -D warnings
-```
-
-### Frontend Development
-
-```powershell
-# Build daemon frontend for development
-cd crates\frontend-daemon
-trunk serve --port 8081
-
-# Build for production
-trunk build --release
-```
-
-### Desktop GUI (Tauri)
-
-```powershell
-# Development mode
-cd crates\gui
-cargo tauri dev
-
-# Build desktop application
-cargo tauri build
-
-# Debug build (faster compilation)
-cargo tauri build --debug
-```
-
-### Using Make (Optional)
-
-If you have `make` available (via Git Bash, WSL, or standalone installation):
-
-```bash
-# View all available commands
-make help
-
-# Development build
-make dev
-
-# Run tests
-make test
-
-# Build GUI application
-make gui-build
-
-# Frontend development server
-make frontend-daemon-dev
-```
-
-## Troubleshooting
-
-### Common Issues
-
-1. **OpenSSL Link Errors**
-   ```
-   error: failed to run custom build command for `openssl-sys`
-   ```
-   **Solution**: Ensure vcpkg is properly installed and integrated. Verify `VCPKG_ROOT` environment variable.
-
-2. **WASM Target Missing**
-   ```
-   error: target 'wasm32-unknown-unknown' not found
-   ```
-   **Solution**: Add the target: `rustup target add wasm32-unknown-unknown`
-
-3. **Trunk Not Found**
-   ```
-   'trunk' is not recognized as an internal or external command
-   ```
-   **Solution**: Ensure Cargo's bin directory is in PATH: `%USERPROFILE%\.cargo\bin`
-
-4. **TailwindCSS Not Found**
-   **Solution**: Verify tailwindcss.exe is in your PATH or add the directory containing it.
-
-### Build Performance Tips
-
-1. **Use PowerShell 7** instead of Windows PowerShell for better performance
-2. **Enable Windows Defender exclusions** for your development directory
-3. **Use SSD storage** for the Rust toolchain and project directory
-4. **Increase virtual memory** if you encounter out-of-memory errors during large builds
-
-### WSL Alternative
-
-For a Unix-like experience, you can use Windows Subsystem for Linux (WSL):
-
-1. Install WSL2 with Ubuntu
-2. Follow the standard Linux development setup within WSL
-3. Access Windows files via `/mnt/c/`
-
-## Development Workflow
-
-1. **Start development server**
-   ```powershell
-   # Terminal 1: Backend
-   cargo run --bin gate
-
-   # Terminal 2: Frontend (if developing UI)
-   cd crates\frontend-daemon
-   trunk serve
-   ```
-
-2. **Build for production**
-   ```powershell
-   # Build everything
-   cargo build --release --all
-
-   # Build desktop application
-   cd crates\gui
-   cargo tauri build
-   ```
-
-3. **Run tests before committing**
-   ```powershell
-   cargo test --all --all-features
-   cargo fmt --all -- --check
-   cargo clippy --all-features -- -D warnings
-   ```
-
-## IDE Setup
-
-### Visual Studio Code
-
-Recommended extensions:
-- `rust-analyzer` - Rust language server
-- `CodeLLDB` - Debugging support
-- `Tauri` - Tauri development support
-- `Even Better TOML` - TOML file support
-
-### CLion/IntelliJ IDEA
-
-- Install the Rust plugin
-- Configure the Rust toolchain path to point to your rustup installation
-
-## Additional Resources
-
-- [Rust Installation Guide](https://forge.rust-lang.org/infra/channel-layout.html)
-- [Tauri Windows Development](https://tauri.app/v1/guides/getting-started/prerequisites/#windows)
-- [vcpkg Documentation](https://vcpkg.io/en/getting-started.html)
-- [Trunk Documentation](https://trunkrs.dev/)
-
-## Support
-
-If you encounter issues not covered in this guide:
-
-1. Check the project's GitHub Issues: https://github.com/hellas-ai/gate/issues
-2. Consult the main CLAUDE.md file for development guidelines
-3. Review the CI workflow in `.github/workflows/ci.yml` for reference build steps
\ No newline at end of file
diff --git a/flake.lock b/flake.lock
index 40533e63..faa7bc6e 100644
--- a/flake.lock
+++ b/flake.lock
@@ -20,15 +20,15 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1756911493,
-        "narHash": "sha256-6n/n1GZQ/vi+LhFXMSyoseKdNfc2QQaSBXJdgamrbkE=",
-        "owner": "nixos",
+        "lastModified": 1787964612,
+        "narHash": "sha256-0N9nghg3nwzX6b6qc77EzjR9cu/Z+UR66FlfsCqiURs=",
+        "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "c6a788f552b7b7af703b1a29802a7233c0067908",
+        "rev": "e8be7818e19ada32105a8af937a6a473b38167ca",
         "type": "github"
       },
       "original": {
-        "owner": "nixos",
+        "owner": "NixOS",
         "ref": "nixpkgs-unstable",
         "repo": "nixpkgs",
         "type": "github"
@@ -48,11 +48,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1757039615,
-        "narHash": "sha256-qm53+EUFfzyF8F0MEscHGqf9tx462GV3/zUZrn9wiQU=",
+        "lastModified": 1788332415,
+        "narHash": "sha256-BTFrmyh0oaVDsvA9NNw0YpbbeppTwU0t70iVx672Ew8=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "4486e04adbb4b0e39f593767f2c36e2211003d01",
+        "rev": "860d7c835ab91bfc8972b67092f5f2db8e9390a0",
         "type": "github"
       },
       "original": {
diff --git a/flake.nix b/flake.nix
index 0662626f..2091eac2 100644
--- a/flake.nix
+++ b/flake.nix
@@ -1,8 +1,8 @@
 {
-  description = "Gate - Free and open source components";
+  description = "Hellas Gate local desktop development shell";
 
   inputs = {
-    nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable";
+    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
     rust-overlay = {
       url = "github:oxalica/rust-overlay";
       inputs.nixpkgs.follows = "nixpkgs";
@@ -10,643 +10,48 @@
     flake-utils.url = "github:numtide/flake-utils";
   };
 
-  outputs = {
-    self,
-    nixpkgs,
-    rust-overlay,
-    flake-utils,
-    ...
-  }:
-    flake-utils.lib.eachDefaultSystem (system: let
-      overlays = [(import rust-overlay)];
-      pkgs = import nixpkgs {
-        inherit system overlays;
-      };
-
-      rustToolchain = pkgs.rust-bin.fromRustupToolchainFile ./rust-toolchain.toml;
-
-      # Create a custom rustPlatform that uses our nightly toolchain
-      customRustPlatform = pkgs.makeRustPlatform {
-        cargo = rustToolchain;
-        rustc = rustToolchain;
-        stdenv =
-          if pkgs.stdenv.isLinux
-          then pkgs.stdenvAdapters.useMoldLinker pkgs.stdenv
-          else pkgs.stdenv;
-      };
-
-      # Create filtered source for Rust builds
-      filteredSource = pkgs.lib.fileset.toSource {
-        root = ./.;
-        fileset = pkgs.lib.fileset.unions [
-          (pkgs.lib.fileset.fileFilter (file: file.name == "Cargo.toml" || file.name == "build.rs") ./crates)
-          (pkgs.lib.fileset.fileFilter (file: pkgs.lib.hasSuffix ".rs" file.name) ./.)
-          ./Cargo.toml
-          ./Cargo.lock
-          ./rust-toolchain.toml
-          ./crates/sqlx/migrations
-        ];
-      };
-
-      # Helper function to create frontend source for a specific frontend crate
-      mkFrontendSource = frontendName:
-        pkgs.lib.fileset.toSource {
-          root = ./.;
-          fileset = pkgs.lib.fileset.unions [
-            # Include all the base Rust files
-            (pkgs.lib.fileset.fileFilter (file: pkgs.lib.hasSuffix ".rs" file.name) ./.)
-            ./Cargo.toml
-            ./Cargo.lock
-            # Include crates directory structure with Cargo.toml files
-            (pkgs.lib.fileset.fileFilter
-              (file: file.name == "Cargo.toml" || file.name == "build.rs" || file.name == "Trunk.toml" || file.name == "index.html" || file.name == "tailwind.config.js")
-              ./crates)
-            ./rust-toolchain.toml
-            # Include the entire frontend directory
-            ./crates/${frontendName}
-            # Include frontend-common
-            ./crates/frontend-common
-            # Include chat-ui
-            ./crates/chat-ui
-          ];
-        };
-
-      # Shared toolset for frontend builds (DRY)
-      frontendTools = with pkgs; [
-        trunk
-        wasm-bindgen-cli
-        tailwindcss_4
-      ];
-
-      # Frontend sources for each variant
-      frontendDaemonSource = mkFrontendSource "frontend-daemon";
-      frontendTauriSource = mkFrontendSource "frontend-tauri";
-      frontendRelaySource = mkFrontendSource "frontend-relay";
-
-      # Filtered source for GUI (includes frontend assets and tauri config)
-      guiSource = pkgs.lib.fileset.toSource {
-        root = ./.;
-        fileset = pkgs.lib.fileset.unions [
-          # Include all the base Rust files
-          (pkgs.lib.fileset.fileFilter (file: pkgs.lib.hasSuffix ".rs" file.name) ./.)
-          ./Cargo.toml
-          ./Cargo.lock
-          # Include crates directory structure with Cargo.toml files
-          (pkgs.lib.fileset.fileFilter
-            (file: file.name == "Cargo.toml" || file.name == "build.rs")
-            ./crates)
-          ./rust-toolchain.toml
-          # Include frontend files for building
-          ./crates/frontend-tauri/index.html
-          ./crates/frontend-tauri/Trunk.toml
-          ./crates/frontend-tauri/style.css
-          (pkgs.lib.fileset.maybeMissing ./crates/frontend-tauri/assets)
-          ./crates/frontend-tauri/tailwind.config.js
-          ./crates/frontend-tauri/.gitignore
-          # Include frontend-common
-          ./crates/frontend-common
-          # Include GUI-specific files
-          ./crates/gui/tauri.conf.json
-          ./crates/gui/icons
-        ];
-      };
-    in {
-      formatter = pkgs.nixpkgs-fmt;
-
-      devShells.default = pkgs.mkShell {
-        nativeBuildInputs = with pkgs; [
-          pkg-config
-        ] ++ frontendTools;
-
-        buildInputs = with pkgs;
-          [
-            rustToolchain
-            openssl
-            protobuf
+  outputs = { nixpkgs, rust-overlay, flake-utils, ... }:
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        pkgs = import nixpkgs {
+          inherit system;
+          overlays = [ (import rust-overlay) ];
+        };
+        rust = pkgs.rust-bin.fromRustupToolchainFile ./rust-toolchain.toml;
+      in
+      {
+        formatter = pkgs.nixpkgs-fmt;
+        devShells.default = pkgs.mkShell {
+          nativeBuildInputs = with pkgs; [
+            cargo-tauri
             clang
-          ]
-          ++ pkgs.lib.optionals pkgs.stdenv.isLinux [
-            mold
-            # libsoup_3
-            pango
-            gdk-pixbuf
+            esbuild
+            nodejs
+            pkg-config
+            rust
+            typescript
+          ];
+          buildInputs = with pkgs; lib.optionals stdenv.hostPlatform.isLinux [
+            sqlite
             atk
-            webkitgtk_4_1
             cairo
-            gio-sharp
-            gtk3
-          ]
-          ++ [
-            # Development tools
-            sqlx-cli
-            cargo-watch
-            cargo-nextest
-            cargo-expand
-            cargo-outdated
-            cargo-edit
-            cargo-machete
-            cargo-udeps
-            cargo-audit
-            cargo-sort
-            cargo-unused-features
-            cargo-depgraph
-            cargo-bloat
-
-            # Python for testing llm-streams and icon conversion
-            (python3.withPackages (ps:
-              with ps; [
-                pytest
-                vcrpy
-                python-dotenv
-                pytest-recording
-                requests
-                nest-asyncio
-                pytest-asyncio
-                httpx
-                openai
-                anthropic
-                pydantic
-                # Icon conversion tools
-                cairosvg
-                pillow
-              ]))
-
-            # Wasm tools
-            wasm-pack
-
-            # Tauri tools
-            cargo-tauri
-
-            # github
-            act
-            gh
-
-            # Image conversion tools
-            librsvg # provides rsvg-convert
-            imagemagick
-          ]
-          ++ pkgs.lib.optionals pkgs.stdenv.isLinux [
-            # Linux-specific GUI dependencies
+            gdk-pixbuf
+            glib
+            glib-networking
             gtk3
             libsoup_3
-            webkitgtk_4_1
-            glib-networking
             libappindicator-gtk3
-          ]
-          ++ pkgs.lib.optionals pkgs.stdenv.isDarwin [
-            # macOS-specific dependencies
-            # darwin.apple_sdk.
+            pango
+            webkitgtk_4_1
           ];
-
-        RUST_SRC_PATH = "${rustToolchain}/lib/rustlib/src/rust/library";
-
-        # Fix for dynamic library loading during build
-        LD_LIBRARY_PATH = "${pkgs.openssl.out}/lib:${pkgs.stdenv.cc.cc.lib}/lib";
-      };
-
-      # Export rustToolchain and customRustPlatform for use by other flakes
-      inherit rustToolchain customRustPlatform;
-
-      # Package outputs
-      packages = let
-        outputHashes = {
-          "catgrad-0.1.1" = "sha256-Im5fhCYqlX1LVtDLncWHIk1CPW+fnhncGYjbZofGRZQ=";
-          "yew-0.21.0" = "sha256-yLPQ5+qKSxFDilvz9dquK+tUvwLvdTHnx1Udx8Suvms=";
-        };
-      in {
-        # Frontend packages - built separately for better caching
-        gate-frontend-daemon = customRustPlatform.buildRustPackage {
-          pname = "gate-frontend-daemon";
-          version = "0.1.0";
-          src = frontendDaemonSource;
-          cargoLock = {
-            lockFile = ./Cargo.lock;
-            inherit outputHashes;
-          };
-
-          nativeBuildInputs = [
-            pkgs.openssl
-          ] ++ frontendTools;
-
-          # Skip normal cargo build
-          buildPhase = ''
-            runHook preBuild
-
-            cd crates/frontend-daemon
-            trunk build --release
-
-            runHook postBuild
-          '';
-
-          # Skip normal cargo install
-          installPhase = ''
-            runHook preInstall
-
-            mkdir -p $out
-            cp -r dist/* $out/
-
-            runHook postInstall
-          '';
-
-          # Don't run tests
-          doCheck = false;
-        };
-
-        gate-frontend-tauri = customRustPlatform.buildRustPackage {
-          pname = "gate-frontend-tauri";
-          version = "0.1.0";
-          src = frontendTauriSource;
-          cargoLock = {
-            lockFile = ./Cargo.lock;
-            inherit outputHashes;
-          };
-
-          nativeBuildInputs = [
-            pkgs.openssl
-          ] ++ frontendTools;
-
-          # Skip normal cargo build
-          buildPhase = ''
-            runHook preBuild
-
-            cd crates/frontend-tauri
-            trunk build --release
-
-            runHook postBuild
-          '';
-
-          # Skip normal cargo install
-          installPhase = ''
-            runHook preInstall
-
-            mkdir -p $out
-            cp -r dist/* $out/
-
-            runHook postInstall
-          '';
-
-          # Don't run tests
-          doCheck = false;
-        };
-
-        gate-frontend-relay = customRustPlatform.buildRustPackage {
-          pname = "gate-frontend-relay";
-          version = "0.1.0";
-          src = frontendRelaySource;
-          cargoLock = {
-            lockFile = ./Cargo.lock;
-            inherit outputHashes;
-          };
-
-          nativeBuildInputs = [
-            pkgs.openssl
-          ] ++ frontendTools;
-
-          # Skip normal cargo build
-          buildPhase = ''
-            runHook preBuild
-
-            cd crates/frontend-relay
-            trunk build --release
-
-            runHook postBuild
-          '';
-
-          # Skip normal cargo install
-          installPhase = ''
-            runHook preInstall
-
-            mkdir -p $out
-            cp -r dist/* $out/
-
-            runHook postInstall
-          '';
-
-          # Don't run tests
-          doCheck = false;
-        };
-
-        # Daemon package - just builds the Rust binary
-        gate-daemon = customRustPlatform.buildRustPackage {
-          pname = "gate-daemon";
-          version = "0.1.0";
-          src = filteredSource;
-          cargoLock = {
-            lockFile = ./Cargo.lock;
-            inherit outputHashes;
-          };
-          cargoBuildFlags = ["--package" "gate-daemon"];
-          doCheck = false;
-          nativeBuildInputs = with pkgs; [pkg-config openssl];
-          buildInputs = with pkgs;
-            [openssl]
-            ++ pkgs.lib.optionals pkgs.stdenv.isLinux [
-              libsoup_3
-              pango
-              gdk-pixbuf
-              atk
-              webkitgtk_4_1
-              cairo
-              gio-sharp
-              gtk3
-            ];
-          # Allow warnings during build
-          RUSTFLAGS = "-A warnings";
-        };
-
-        # Combined package with launcher script
-        gate = pkgs.symlinkJoin {
-          name = "gate";
-          paths = [self.packages.${system}.gate-daemon];
-          nativeBuildInputs = [pkgs.makeWrapper];
-          postBuild = ''
-            # Create launcher wrapper
-            makeWrapper $out/bin/gate $out/bin/gate-launcher \
-              --set GATE_SERVER__STATIC_DIR "${self.packages.${system}.gate-frontend-daemon}" \
-              --prefix PATH : "${pkgs.lib.makeBinPath [pkgs.curl]}" \
-              --run 'echo "Starting Gate daemon..."' \
-              --run 'trap "echo -e \"\\nShutting down Gate daemon...\"" EXIT'
-
-            # Create a more sophisticated launcher script
-            cat > $out/bin/gate-with-browser << 'EOF'
-            #!${pkgs.bash}/bin/bash
-            set -e
-
-            # Configuration
-            GATE_PORT="''${GATE_PORT:-3000}"
-            GATE_HOST="''${GATE_HOST:-localhost}"
-            GATE_URL="http://''${GATE_HOST}:''${GATE_PORT}"
-
-            # Set static files directory
-            export GATE_SERVER__STATIC_DIR="${self.packages.${system}.gate-frontend-daemon}"
-            echo "DEBUG: Static files directory set to: $GATE_SERVER__STATIC_DIR"
-
-            # Function to check if server is ready
-            wait_for_server() {
-              echo "Waiting for Gate daemon to start..."
-              for i in {1..30}; do
-                if ${pkgs.curl}/bin/curl -s -o /dev/null "''${GATE_URL}/health"; then
-                  echo "Gate daemon is ready!"
-                  return 0
-                fi
-                sleep 0.5
-              done
-              echo "Gate daemon failed to start"
-              return 1
-            }
-
-            # Function to open browser
-            open_browser() {
-              if [ "''${GATE_NO_BROWSER:-}" != "1" ]; then
-                echo "Opening browser at ''${GATE_URL}"
-                if command -v xdg-open >/dev/null 2>&1; then
-                  xdg-open "''${GATE_URL}" 2>/dev/null || true
-                elif command -v open >/dev/null 2>&1; then
-                  open "''${GATE_URL}" 2>/dev/null || true
-                else
-                  echo "Please open your browser and navigate to ''${GATE_URL}"
-                fi
-              fi
-            }
-
-            # Start the daemon
-            echo "Starting Gate daemon..."
-            ${self.packages.${system}.gate-daemon}/bin/gate &
-            GATE_PID=$!
-
-            # Set up signal handlers for clean shutdown
-            cleanup() {
-              echo -e "\nShutting down Gate daemon..."
-              kill $GATE_PID 2>/dev/null || true
-              wait $GATE_PID 2>/dev/null || true
-              exit 0
-            }
-            trap cleanup INT TERM
-
-            # Wait for server and open browser
-            if wait_for_server; then
-              open_browser
-              echo "Gate is running at ''${GATE_URL}"
-              echo "Press Ctrl+C to stop"
-              # Wait for the daemon process
-              wait $GATE_PID
-            else
-              kill $GATE_PID 2>/dev/null || true
-              exit 1
-            fi
-            EOF
-
-            chmod +x $out/bin/gate-with-browser
+          shellHook = ''
+            export CARGO_TARGET_DIR="''${CARGO_TARGET_DIR:-/tmp/hellas-gate-target}"
+          '' + pkgs.lib.optionalString pkgs.stdenv.hostPlatform.isDarwin ''
+            export DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer
+            export SDKROOT="$(/usr/bin/xcrun --sdk macosx --show-sdk-path)"
+            export CARGO_TARGET_AARCH64_APPLE_DARWIN_LINKER=/usr/bin/clang
+            export CARGO_TARGET_X86_64_APPLE_DARWIN_LINKER=/usr/bin/clang
           '';
         };
-        gate-tlsforward = customRustPlatform.buildRustPackage {
-          pname = "gate-tlsforward";
-          version = "0.1.0";
-          src = filteredSource;
-          cargoLock = {
-            lockFile = ./Cargo.lock;
-            inherit outputHashes;
-          };
-          buildFeatures = ["server"];
-          cargoBuildFlags = ["--package" "gate-tlsforward"];
-          doCheck = false;
-          nativeBuildInputs = with pkgs; [pkg-config];
-          buildInputs = with pkgs; [openssl];
-          # Allow warnings during build
-          RUSTFLAGS = "-A warnings";
-        };
-
-        # GUI package with Tauri
-        gate-gui = customRustPlatform.buildRustPackage {
-          pname = "gate-gui";
-          version = "0.1.0";
-          src = guiSource;
-
-          # Don't set cargoRoot since we're using workspace Cargo.lock
-          buildAndTestSubdir = "crates/gui";
-
-          cargoLock = {
-            lockFile = ./Cargo.lock;
-            inherit outputHashes;
-          };
-
-          nativeBuildInputs = with pkgs;
-            [
-              pkg-config
-              cargo-tauri.hook
-              nodePackages.nodejs
-              makeWrapper
-            ]
-            ++ frontendTools
-            ++ pkgs.lib.optionals pkgs.stdenv.isDarwin [
-              darwin.apple_sdk.frameworks.WebKit
-              darwin.apple_sdk.frameworks.AppKit
-              darwin.apple_sdk.frameworks.CoreServices
-              # Tools needed for DMG creation
-              libicns
-              imagemagick
-              makeBinaryWrapper
-              # Additional DMG tools
-              darwin.cctools
-              (pkgs.writeShellScriptBin "hdiutil" ''
-                # Wrapper for hdiutil to ensure it can find necessary tools
-                export PATH="${pkgs.coreutils}/bin:${pkgs.findutils}/bin:$PATH"
-                exec /usr/bin/hdiutil "$@"
-              '')
-            ];
-
-          buildInputs = with pkgs;
-            [
-              openssl
-            ]
-            ++ pkgs.lib.optionals pkgs.stdenv.isLinux [
-              gtk3
-              libsoup_3
-              webkitgtk_4_1
-              cairo
-              gdk-pixbuf
-              glib
-              pango
-              atk
-              glib-networking
-              libappindicator-gtk3
-            ]
-            ++ pkgs.lib.optionals pkgs.stdenv.isDarwin [
-              darwin.apple_sdk.frameworks.WebKit
-              darwin.apple_sdk.frameworks.AppKit
-              darwin.apple_sdk.frameworks.CoreServices
-              darwin.apple_sdk.frameworks.Security
-              darwin.apple_sdk.frameworks.CoreGraphics
-              darwin.apple_sdk.frameworks.CoreFoundation
-              darwin.apple_sdk.frameworks.Foundation
-              darwin.apple_sdk.frameworks.ApplicationServices
-            ];
-
-          # Disable default cargo build phases since cargo-tauri.hook handles it
-          dontCargoCheck = true;
-          doCheck = false;
-
-          # Set environment variables
-          WEBKIT_DISABLE_DMABUF_RENDERER = "1"; # Fix for WebKit on some Linux systems
-
-          # Tauri-specific configuration
-          tauriBuildFlags =
-            if pkgs.stdenv.isLinux
-            then "--bundles deb,appimage"
-            else if pkgs.stdenv.isDarwin
-            then "--bundles app,dmg"
-            else "";
-
-          # cargo-tauri.hook will handle everything, including running
-          # the beforeBuildCommand from tauri.conf.json
-
-          # Handle platform-specific setup
-          preBuild = pkgs.lib.optionalString pkgs.stdenv.isDarwin ''
-            # Ensure DMG creation script can find tools
-            export PATH="${pkgs.coreutils}/bin:${pkgs.findutils}/bin:${pkgs.gnutar}/bin:$PATH"
-
-            # Create wrapper for SetFile if needed
-            mkdir -p $TMPDIR/bin
-            cat > $TMPDIR/bin/SetFile << 'EOF'
-            #!/bin/bash
-            # Stub for SetFile - not critical for DMG creation
-            exit 0
-            EOF
-            chmod +x $TMPDIR/bin/SetFile
-            export PATH="$TMPDIR/bin:$PATH"
-          '';
-
-          postInstall = ''
-            # Wrap the binary with library paths on Linux
-            if [[ -f $out/bin/gate-gui ]] && [[ "$(uname)" = "Linux" ]]; then
-              wrapProgram $out/bin/gate-gui \
-                --prefix LD_LIBRARY_PATH : "${pkgs.lib.makeLibraryPath (with pkgs; [
-              gtk3
-              libsoup_3
-              webkitgtk_4_1
-              cairo
-              gdk-pixbuf
-              glib
-              pango
-              atk
-              glib-networking
-              libappindicator-gtk3
-            ])}" \
-                --prefix GIO_MODULE_DIR : "${pkgs.glib-networking}/lib/gio/modules" \
-                --set WEBKIT_DISABLE_DMABUF_RENDERER "1"
-            fi
-
-            # Handle platform-specific bundle installation
-            if [[ -d target/release/bundle ]]; then
-              # Linux bundles
-              if [[ -d target/release/bundle/deb ]]; then
-                mkdir -p $out/share/applications
-
-                # Install desktop file if it exists
-                if [[ -f target/release/bundle/deb/gate-gui.desktop ]]; then
-                  cp target/release/bundle/deb/gate-gui.desktop $out/share/applications/
-                fi
-              fi
-
-              # Install AppImage if built
-              if [[ -f target/release/bundle/appimage/gate-gui_*.AppImage ]]; then
-                mkdir -p $out/bin
-                cp target/release/bundle/appimage/gate-gui_*.AppImage $out/bin/gate-gui.AppImage
-                chmod +x $out/bin/gate-gui.AppImage
-              fi
-
-              # macOS bundles
-              if [[ -d target/release/bundle/macos ]]; then
-                mkdir -p $out/Applications
-                cp -r target/release/bundle/macos/*.app $out/Applications/ || true
-
-                # Create a wrapper script for command-line usage
-                mkdir -p $out/bin
-                cat > $out/bin/gate-gui << 'EOF'
-            #!/bin/bash
-            exec "$out/Applications/Gate.app/Contents/MacOS/gate-gui" "$@"
-            EOF
-                chmod +x $out/bin/gate-gui
-              fi
-
-              # Install DMG if built (for distribution)
-              if [[ -f target/release/bundle/dmg/*.dmg ]]; then
-                mkdir -p $out/share
-                cp target/release/bundle/dmg/*.dmg $out/share/
-              fi
-            fi
-          '';
-
-          # Allow warnings during build
-          RUSTFLAGS = "-A warnings";
-        };
-
-        default = self.packages.${system}.gate;
-      };
-
-      # Apps for nix run
-      apps = {
-        default = {
-          type = "app";
-          program = "${self.packages.${system}.gate}/bin/gate-with-browser";
-        };
-        gate = self.apps.${system}.default;
-        gate-gui = {
-          type = "app";
-          program = "${self.packages.${system}.gate-gui}/bin/gate-gui";
-        };
-      };
-    })
-    // {
-      # Overlay for adding gate packages to nixpkgs
-      overlays.default = import ./nix/overlay.nix self;
-
-      # NixOS modules
-      nixosModules = {
-        default = import ./nix/modules/default.nix;
-        tlsforward = import ./nix/modules/tlsforward.nix;
-        tlsforward-colmena = import ./nix/modules/tlsforward-colmena.nix;
-        daemon = import ./nix/modules/daemon.nix;
-      };
-    };
+      });
 }
diff --git a/macos/sign.sh b/macos/sign.sh
new file mode 100755
index 00000000..194911d7
--- /dev/null
+++ b/macos/sign.sh
@@ -0,0 +1,62 @@
+#!/bin/sh
+set -eu
+
+profile=${1:?usage: macos/sign.sh PROFILE APP}
+app=${2:?usage: macos/sign.sh PROFILE APP}
+identity=${SIGN_IDENTITY:-}
+contents="$app/Contents"
+
+test -f "$profile"
+test -d "$contents"
+test -f "$contents/Info.plist"
+
+temporary=$(mktemp -d /tmp/hellas-gate-sign.XXXXXX)
+trap 'rm -r "$temporary"' EXIT HUP INT TERM
+decoded="$temporary/profile.plist"
+entitlements="$temporary/entitlements.plist"
+
+security cms -D -i "$profile" >"$decoded"
+plutil -extract Entitlements xml1 -o "$entitlements" "$decoded"
+
+application_id=$(/usr/libexec/PlistBuddy \
+    -c 'Print :com.apple.application-identifier' "$entitlements")
+profile_bundle_id=${application_id#*.}
+app_bundle_id=$(/usr/libexec/PlistBuddy -c 'Print :CFBundleIdentifier' \
+    "$contents/Info.plist")
+if [ "$profile_bundle_id" != "$app_bundle_id" ]; then
+    echo "error: profile is for $profile_bundle_id, app is $app_bundle_id" >&2
+    exit 1
+fi
+
+test "$(/usr/libexec/PlistBuddy \
+    -c 'Print :com.apple.developer.devicecheck.app-attest-opt-in:0' \
+    "$entitlements")" = CDhash
+
+for entitlement in \
+    com.apple.security.get-task-allow \
+    com.apple.security.cs.allow-jit \
+    com.apple.security.cs.allow-dyld-environment-variables \
+    com.apple.security.cs.disable-library-validation \
+    com.apple.security.cs.allow-unsigned-executable-memory \
+    com.apple.security.cs.disable-executable-page-protection \
+    com.apple.security.cs.debugger
+do
+    if /usr/libexec/PlistBuddy -c "Print :$entitlement" \
+        "$entitlements" >/dev/null 2>&1
+    then
+        echo "error: forbidden runtime-relaxation entitlement: $entitlement" >&2
+        exit 1
+    fi
+done
+
+if [ -z "$identity" ]; then
+    identity=$(security find-identity -v -p codesigning \
+        | sed -n 's/.*"\(Developer ID Application:[^"]*\)".*/\1/p' \
+        | head -n 1)
+fi
+test -n "$identity"
+
+cp "$profile" "$contents/embedded.provisionprofile"
+codesign --force --options runtime --timestamp --entitlements "$entitlements" \
+    --sign "$identity" "$app"
+codesign --verify --deep --strict --verbose=2 "$app"
diff --git a/nix/README.md b/nix/README.md
deleted file mode 100644
index 51d073ee..00000000
--- a/nix/README.md
+++ /dev/null
@@ -1,177 +0,0 @@
-# Gate NixOS Modules
-
-This directory contains NixOS modules and overlays for deploying Gate services.
-
-## Usage
-
-### In a NixOS Configuration
-
-Add gate to your flake inputs:
-
-```nix
-{
-  inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
-    gate.url = "github:hellas-ai/gate";
-  };
-
-  outputs = { self, nixpkgs, gate, ... }: {
-    nixosConfigurations.myserver = nixpkgs.lib.nixosSystem {
-      modules = [
-        gate.nixosModules.default
-        {
-          services.gate-daemon = {
-            enable = true;
-            port = 8080;
-            initialUpstreams = [{
-              name = "openai";
-              provider = "openai";
-            }];
-          };
-        }
-      ];
-    };
-  };
-}
-```
-
-### Available Modules
-
-#### `gate-daemon`
-
-The main Gate service that provides the AI gateway functionality.
-
-```nix
-services.gate-daemon = {
-  enable = true;
-  
-  # Network configuration
-  host = "127.0.0.1";
-  port = 3000;
-  p2pPort = 41147;
-  
-  # Firewall options
-  openFirewall = true;  # Opens on all interfaces
-  openFirewallOnInterfaces = [ "eth0" "wg0" ];  # Or specific interfaces
-  
-  # Initial upstream providers (API keys added at runtime)
-  initialUpstreams = [
-    { name = "openai"; provider = "openai"; }
-    { name = "anthropic"; provider = "anthropic"; }
-  ];
-  
-  # Relay client configuration
-  relay = {
-    enable = true;
-    addresses = [ "relay.hellas.ai:443" ];
-    customDomain = "myserver";  # Optional: myserver.gate.hellas.ai
-  };
-  
-  # Environment file for secrets
-  environmentFile = "/run/secrets/gate-daemon";
-};
-```
-
-#### `gate-relay`
-
-The relay server that enables P2P connections and HTTPS proxying.
-
-```nix
-services.gate-relay = {
-  enable = true;
-  
-  instances.default = {
-    enable = true;
-    httpsPort = 443;
-    p2pPort = 31145;
-    logLevel = "info";
-    
-    # Firewall configuration
-    openFirewallOnInterfaces = [ "eth0" ];
-    
-    # DNS provider settings
-    domainSuffix = "gate.hellas.ai";
-    dns = {
-      enabled = true;
-      provider = "cloudflare";
-    };
-    
-    # Secrets via environment file
-    environmentFile = "/run/secrets/gate-relay";
-  };
-};
-```
-
-### Runtime Configuration
-
-Gate daemon supports runtime configuration for flexibility:
-
-1. **Initial Configuration**: Set via NixOS module options
-2. **Runtime Configuration**: Modified via web UI or CLI
-3. **Configuration Priority**: Environment > Runtime > Nix > Defaults
-
-Runtime configuration is stored in `/var/lib/gate/config.toml` and persists across restarts.
-
-### Secrets Management
-
-Sensitive values should be provided via environment files:
-
-```bash
-# /run/secrets/gate-daemon
-GATE_AUTH__JWT__SECRET=your-secret-here
-GATE_UPSTREAMS__OPENAI__API_KEY=sk-...
-GATE_LETSENCRYPT__EMAIL=admin@example.com
-
-# /run/secrets/gate-relay
-RELAY__DNS__CLOUDFLARE__API_TOKEN=your-token
-RELAY__DNS__CLOUDFLARE__ZONE_ID=your-zone-id
-```
-
-### Overlay Usage
-
-To add Gate packages to your nixpkgs:
-
-```nix
-{
-  nixpkgs.overlays = [ gate.overlays.default ];
-  
-  environment.systemPackages = with pkgs; [
-    gate-daemon
-    gate-relay
-  ];
-}
-```
-
-## Development
-
-### Testing Modules Locally
-
-```bash
-# Build and test a configuration
-nix build -f '<nixpkgs/nixos>' system \
-  --arg configuration ./nix/test-config.nix
-
-# Run in a VM
-nixos-rebuild build-vm \
-  --flake .#test-vm
-```
-
-### Multiple Instances
-
-Both services support running multiple instances:
-
-```nix
-services.gate-relay.instances = {
-  public = {
-    enable = true;
-    httpsPort = 443;
-    p2pPort = 31145;
-  };
-  internal = {
-    enable = true;
-    httpsPort = 8443;
-    p2pPort = 31146;
-    bindAddress = "10.0.0.1";
-  };
-};
-```
\ No newline at end of file
diff --git a/nix/modules/daemon.nix b/nix/modules/daemon.nix
deleted file mode 100644
index b8137603..00000000
--- a/nix/modules/daemon.nix
+++ /dev/null
@@ -1,515 +0,0 @@
-{ pkgs
-, lib
-, config
-, ...
-}:
-let
-  cfg = config.services.gate-daemon;
-  
-  # Format upstream configuration for the config file
-  formatUpstream = upstream: {
-    inherit (upstream) name provider base_url;
-    # API key will be added at runtime
-  };
-  
-  # Generate the initial configuration file for an instance
-  mkInstanceConfig = name: instanceCfg: 
-    let
-      stateDir = if instanceCfg.stateDir != null 
-        then instanceCfg.stateDir 
-        else "/var/lib/gate-daemon-${name}";
-    in {
-      server = {
-        host = instanceCfg.host;
-        port = instanceCfg.port;
-        cors_origins = instanceCfg.corsOrigins;
-        metrics_port = instanceCfg.metricsPort;
-      };
-      database = {
-        url = "sqlite://${stateDir}/db.sqlite";
-        max_connections = 10;
-      };
-      plugins = {
-        enabled = instanceCfg.plugins.enabled;
-        directories = instanceCfg.plugins.directories;
-      };
-      auth = {
-        webauthn = instanceCfg.auth.webauthn;
-        jwt = {
-          issuer = instanceCfg.auth.jwt.issuer;
-          expiration_hours = instanceCfg.auth.jwt.expirationHours;
-          # Secret provided via environment
-        };
-      };
-      upstreams = map formatUpstream instanceCfg.initialUpstreams;
-      tlsforward = {
-        enabled = instanceCfg.tlsforward.enable;
-        tlsforward_addresses = instanceCfg.tlsforward.addresses;
-        custom_domain = instanceCfg.tlsforward.customDomain;
-        secret_key_path = "${stateDir}/keys/tlsforward-secret";
-        heartbeat_interval = instanceCfg.tlsforward.heartbeatInterval;
-        auto_reconnect = instanceCfg.tlsforward.autoReconnect;
-        max_reconnect_attempts = instanceCfg.tlsforward.maxReconnectAttempts;
-        reconnect_backoff = instanceCfg.tlsforward.reconnectBackoff;
-      };
-      letsencrypt = instanceCfg.letsencrypt;
-      state_dir = stateDir;
-    };
-  
-  # Helper to create instance configurations
-  mkInstance = name: instanceCfg:
-    let
-      serviceName = "gate-daemon-${name}";
-      userName = "gate-daemon-${name}";
-      stateDir = if instanceCfg.stateDir != null 
-        then instanceCfg.stateDir 
-        else "/var/lib/gate-daemon-${name}";
-      configFile = (pkgs.formats.json {}).generate "gate-daemon-${name}-startup.json" (mkInstanceConfig name instanceCfg);
-    in {
-      inherit serviceName userName stateDir configFile;
-      config = instanceCfg;
-    };
-in
-{
-  options.services.gate-daemon = {
-    enable = lib.mkEnableOption "Gate daemon service";
-    
-    package = lib.mkOption {
-      type = lib.types.package;
-      default = pkgs.gate-daemon;
-      defaultText = lib.literalExpression "pkgs.gate-daemon";
-      description = "The gate-daemon package to use";
-    };
-
-    instances = lib.mkOption {
-      type = lib.types.attrsOf (lib.types.submodule {
-        options = {
-          enable = lib.mkEnableOption "this daemon instance";
-
-          frontendPackage = lib.mkOption {
-            type = lib.types.nullOr lib.types.package;
-            default = if (pkgs ? gate-frontend-daemon) then pkgs.gate-frontend-daemon else null;
-            defaultText = lib.literalExpression "pkgs.gate-frontend-daemon";
-            description = "The frontend package containing static files to serve";
-          };
-
-          host = lib.mkOption {
-            type = lib.types.str;
-            default = "127.0.0.1";
-            description = "Host to bind the HTTP server to";
-          };
-
-          port = lib.mkOption {
-            type = lib.types.port;
-            default = 3000;
-            description = "HTTP port to bind to";
-          };
-
-          p2pPort = lib.mkOption {
-            type = lib.types.port;
-            default = 41147;
-            description = "P2P port for TLS forward connections";
-          };
-
-          metricsPort = lib.mkOption {
-            type = lib.types.nullOr lib.types.port;
-            default = null;
-            example = 9091;
-            description = "Prometheus metrics endpoint port. If null, metrics endpoint is disabled.";
-          };
-
-          corsOrigins = lib.mkOption {
-            type = lib.types.listOf lib.types.str;
-            default = [];
-            description = "CORS allowed origins";
-          };
-
-          stateDir = lib.mkOption {
-            type = lib.types.nullOr lib.types.str;
-            default = null;
-            description = "State directory for database, runtime config, and keys. Defaults to /var/lib/gate-daemon-{name}";
-          };
-
-          logLevel = lib.mkOption {
-            type = lib.types.enum ["error" "warn" "info" "debug" "trace"];
-            default = "info";
-            description = "Log level for the service";
-          };
-
-          environmentFile = lib.mkOption {
-            type = lib.types.nullOr lib.types.path;
-            default = null;
-            description = ''
-              Path to environment file containing secrets.
-              Can define:
-              - GATE_AUTH__JWT__SECRET
-              - GATE_UPSTREAMS__<NAME>__API_KEY
-              - GATE_LETSENCRYPT__EMAIL
-            '';
-          };
-
-          otlpEndpoint = lib.mkOption {
-            type = lib.types.nullOr lib.types.str;
-            default = null;
-            example = "http://localhost:4318";
-            description = ''
-              OpenTelemetry Protocol (OTLP) endpoint for exporting traces and metrics.
-              If set, enables telemetry export to Jaeger or other OTLP collectors.
-            '';
-          };
-
-          openFirewall = lib.mkOption {
-            type = lib.types.bool;
-            default = false;
-            description = "Open firewall ports on all interfaces";
-          };
-
-          openFirewallOnInterfaces = lib.mkOption {
-            type = lib.types.listOf lib.types.str;
-            default = [];
-            description = "List of network interfaces to open firewall ports on";
-          };
-
-          initialUpstreams = lib.mkOption {
-            type = lib.types.listOf (lib.types.submodule {
-              options = {
-                name = lib.mkOption {
-                  type = lib.types.str;
-                  description = "Name identifier for this upstream";
-                };
-                provider = lib.mkOption {
-                  type = lib.types.enum ["openai" "anthropic" "google" "mistral" "groq" "openrouter" "custom"];
-                  description = "LLM provider type";
-                };
-                base_url = lib.mkOption {
-                  type = lib.types.str;
-                  default = "";
-                  description = "Base URL for the upstream API (uses provider default if empty)";
-                };
-              };
-            });
-            default = [];
-            description = "Initial upstream providers (API keys configured at runtime)";
-          };
-
-          plugins = lib.mkOption {
-            type = lib.types.submodule {
-              options = {
-                enabled = lib.mkOption {
-                  type = lib.types.bool;
-                  default = true;
-                  description = "Enable plugin system";
-                };
-                directories = lib.mkOption {
-                  type = lib.types.listOf lib.types.str;
-                  default = [];
-                  description = "Plugin directories to load from";
-                };
-              };
-            };
-            default = {};
-            description = "Plugin configuration";
-          };
-
-          auth = lib.mkOption {
-            type = lib.types.submodule {
-              options = {
-                webauthn = lib.mkOption {
-                  type = lib.types.submodule {
-                    options = {
-                      enabled = lib.mkOption {
-                        type = lib.types.bool;
-                        default = false;
-                        description = "Enable WebAuthn authentication";
-                      };
-                      rpId = lib.mkOption {
-                        type = lib.types.str;
-                        default = "localhost";
-                        description = "Relying Party ID (usually domain name)";
-                      };
-                      rpName = lib.mkOption {
-                        type = lib.types.str;
-                        default = "Gate Self-Hosted";
-                        description = "Relying Party Name (display name)";
-                      };
-                      rpOrigin = lib.mkOption {
-                        type = lib.types.str;
-                        example = "https://gate.example.com";
-                        description = "Relying Party Origin (full URL). This should match the URL users access your service from.";
-                      };
-                      allowedOrigins = lib.mkOption {
-                        type = lib.types.listOf lib.types.str;
-                        default = [];
-                        description = "Additional allowed origins";
-                      };
-                      allowTlsForwardOrigins = lib.mkOption {
-                        type = lib.types.bool;
-                        default = true;
-                        description = "Allow TLS forward origins automatically (*.hellas.ai domains)";
-                      };
-                      allowSubdomains = lib.mkOption {
-                        type = lib.types.bool;
-                        default = false;
-                        description = "Allow subdomains of configured origins";
-                      };
-                    };
-                  };
-                  default = {};
-                  description = "WebAuthn configuration";
-                };
-                jwt = lib.mkOption {
-                  type = lib.types.submodule {
-                    options = {
-                      issuer = lib.mkOption {
-                        type = lib.types.str;
-                        default = "gate-daemon";
-                        description = "JWT issuer";
-                      };
-                      expirationHours = lib.mkOption {
-                        type = lib.types.int;
-                        default = 24;
-                        description = "Token expiration in hours";
-                      };
-                    };
-                  };
-                  default = {};
-                  description = "JWT configuration";
-                };
-              };
-            };
-            default = {};
-            description = "Authentication configuration";
-          };
-
-          tlsforward = lib.mkOption {
-            type = lib.types.submodule {
-              options = {
-                enable = lib.mkOption {
-                  type = lib.types.bool;
-                  default = false;
-                  description = "Enable TLS forward client functionality";
-                };
-                addresses = lib.mkOption {
-                  type = lib.types.listOf lib.types.str;
-                  default = [];
-                  description = "List of TLS forward server addresses";
-                };
-                customDomain = lib.mkOption {
-                  type = lib.types.nullOr lib.types.str;
-                  default = null;
-                  description = "Custom subdomain preference";
-                };
-                heartbeatInterval = lib.mkOption {
-                  type = lib.types.int;
-                  default = 30;
-                  description = "Heartbeat interval in seconds";
-                };
-                autoReconnect = lib.mkOption {
-                  type = lib.types.bool;
-                  default = true;
-                  description = "Auto-reconnect on disconnect";
-                };
-                maxReconnectAttempts = lib.mkOption {
-                  type = lib.types.int;
-                  default = 10;
-                  description = "Maximum reconnection attempts";
-                };
-                reconnectBackoff = lib.mkOption {
-                  type = lib.types.int;
-                  default = 5;
-                  description = "Reconnection backoff in seconds";
-                };
-              };
-            };
-            default = {};
-            description = "TLS forward client configuration";
-          };
-
-          letsencrypt = lib.mkOption {
-            type = lib.types.submodule {
-              options = {
-                enabled = lib.mkOption {
-                  type = lib.types.bool;
-                  default = false;
-                  description = "Enable Let's Encrypt certificate management";
-                };
-                email = lib.mkOption {
-                  type = lib.types.nullOr lib.types.str;
-                  default = null;
-                  description = "Email address for Let's Encrypt account";
-                };
-                staging = lib.mkOption {
-                  type = lib.types.bool;
-                  default = false;
-                  description = "Use staging environment for testing";
-                };
-                domains = lib.mkOption {
-                  type = lib.types.listOf lib.types.str;
-                  default = [];
-                  description = "Domains to request certificates for";
-                };
-                autoRenewDays = lib.mkOption {
-                  type = lib.types.int;
-                  default = 30;
-                  description = "Auto-renew certificates before expiry (days)";
-                };
-              };
-            };
-            default = {};
-            description = "Let's Encrypt configuration";
-          };
-        };
-      });
-      default = {};
-      description = "Gate daemon instances";
-    };
-  };
-
-  config = lib.mkIf cfg.enable {
-    # Create users and groups for each instance
-    users.groups = lib.mapAttrs' (name: instanceCfg:
-      lib.nameValuePair "gate-daemon-${name}" {}
-    ) (lib.filterAttrs (_: instanceCfg: instanceCfg.enable) cfg.instances);
-
-    users.users = lib.mapAttrs' (name: instanceCfg:
-      lib.nameValuePair "gate-daemon-${name}" {
-        isSystemUser = true;
-        group = "gate-daemon-${name}";
-        home = if instanceCfg.stateDir != null 
-          then instanceCfg.stateDir 
-          else "/var/lib/gate-daemon-${name}";
-        createHome = true;
-      }
-    ) (lib.filterAttrs (_: instanceCfg: instanceCfg.enable) cfg.instances);
-
-    # Create systemd services for each instance
-    systemd.services = lib.mapAttrs' (name: instanceCfg:
-      let
-        instance = mkInstance name instanceCfg;
-      in
-      lib.nameValuePair instance.serviceName {
-        description = "Gate daemon service (${name})";
-        after = [ "network-online.target" ];
-        wants = [ "network-online.target" ];
-        wantedBy = [ "multi-user.target" ];
-
-        preStart = ''
-          # Ensure state directory structure exists
-          mkdir -p ${instance.stateDir}/{config,keys,plugins,data/certs,data/accounts}
-          
-          # Write startup configuration to state directory
-          cat ${instance.configFile} > ${instance.stateDir}/config/startup.json
-          
-          # Set proper permissions
-          chown -R ${instance.userName}:${instance.userName} ${instance.stateDir}
-          chmod 750 ${instance.stateDir}
-          chmod 750 ${instance.stateDir}/config
-          chmod 700 ${instance.stateDir}/keys
-          chmod 755 ${instance.stateDir}/data
-          chmod 755 ${instance.stateDir}/data/certs
-          chmod 700 ${instance.stateDir}/data/accounts
-        '';
-
-        serviceConfig = {
-          Type = "exec";
-          User = instance.userName;
-          Group = instance.userName;
-          ExecStart = "${cfg.package}/bin/gate -c ${instance.stateDir}/config/startup.json";
-          
-          Environment = [
-            "RUST_LOG=${instanceCfg.logLevel}"
-            "GATE_STATE_DIR=${instance.stateDir}"
-          ] ++ lib.optional (instanceCfg.frontendPackage != null) "GATE_SERVER__STATIC_DIR=${instanceCfg.frontendPackage}"
-            ++ lib.optional (instanceCfg.otlpEndpoint != null) "OTLP_ENDPOINT=${instanceCfg.otlpEndpoint}";
-          
-          EnvironmentFile = lib.optional (instanceCfg.environmentFile != null) instanceCfg.environmentFile;
-          
-          # Working directory
-          WorkingDirectory = instance.stateDir;
-          
-          # Logging
-          StandardOutput = "journal";
-          StandardError = "journal";
-          
-          # Restart behavior
-          Restart = "on-failure";
-          RestartSec = "5s";
-          StartLimitBurst = 3;
-          StartLimitIntervalSec = "1m";
-          
-          # Security hardening
-          NoNewPrivileges = true;
-          ProtectSystem = "strict";
-          ProtectHome = true;
-          PrivateTmp = true;
-          PrivateDevices = true;
-          ProtectHostname = true;
-          ProtectClock = true;
-          ProtectKernelTunables = true;
-          ProtectKernelModules = true;
-          ProtectKernelLogs = true;
-          ProtectControlGroups = true;
-          RestrictNamespaces = true;
-          LockPersonality = true;
-          MemoryDenyWriteExecute = true;
-          RestrictRealtime = true;
-          RestrictSUIDSGID = true;
-          RemoveIPC = true;
-          
-          # Allow state directory access
-          StateDirectory = lib.optionalString (instanceCfg.stateDir == null) "gate-daemon-${name}";
-          StateDirectoryMode = "0750";
-          
-          # For custom state directories, we need to allow read/write access
-          ReadWritePaths = lib.optional (instanceCfg.stateDir != null) instanceCfg.stateDir;
-          
-          # Network capabilities for P2P
-          AmbientCapabilities = lib.optional (instanceCfg.tlsforward.enable || instanceCfg.p2pPort < 1024) "CAP_NET_BIND_SERVICE";
-          CapabilityBoundingSet = lib.optional (instanceCfg.tlsforward.enable || instanceCfg.p2pPort < 1024) "CAP_NET_BIND_SERVICE";
-        };
-      }
-    ) (lib.filterAttrs (_: instanceCfg: instanceCfg.enable) cfg.instances);
-
-    # Configure firewall for all instances
-    networking.firewall = let
-      # Collect all TCP ports from all enabled instances
-      allTcpPorts = lib.flatten (lib.mapAttrsToList (name: instanceCfg:
-        let
-          tcpPorts = [instanceCfg.port] 
-            ++ lib.optional instanceCfg.tlsforward.enable instanceCfg.p2pPort
-            ++ lib.optional (instanceCfg.metricsPort != null) instanceCfg.metricsPort;
-        in
-          if instanceCfg.enable && instanceCfg.openFirewall then tcpPorts else []
-      ) cfg.instances);
-      
-      # Collect all UDP ports from all enabled instances
-      allUdpPorts = lib.flatten (lib.mapAttrsToList (name: instanceCfg:
-        let
-          udpPorts = lib.optional instanceCfg.tlsforward.enable instanceCfg.p2pPort;
-        in
-          if instanceCfg.enable && instanceCfg.openFirewall then udpPorts else []
-      ) cfg.instances);
-      
-      # Collect interface-specific rules
-      interfaceRules = lib.foldl' (acc: instance:
-        lib.foldl' (acc2: iface:
-          acc2 // {
-            ${iface} = {
-              allowedTCPPorts = (acc2.${iface}.allowedTCPPorts or []) ++ 
-                [instance.config.port] ++
-                lib.optional instance.config.tlsforward.enable instance.config.p2pPort ++
-                lib.optional (instance.config.metricsPort != null) instance.config.metricsPort;
-              allowedUDPPorts = (acc2.${iface}.allowedUDPPorts or []) ++
-                lib.optional instance.config.tlsforward.enable instance.config.p2pPort;
-            };
-          }
-        ) acc instance.config.openFirewallOnInterfaces
-      ) {} (lib.filter (i: i.config.enable) 
-        (lib.mapAttrsToList (name: cfg: mkInstance name cfg) cfg.instances));
-    in {
-      allowedTCPPorts = allTcpPorts;
-      allowedUDPPorts = allUdpPorts;
-      interfaces = interfaceRules;
-    };
-  };
-}
\ No newline at end of file
diff --git a/nix/modules/default.nix b/nix/modules/default.nix
deleted file mode 100644
index 2cf418ea..00000000
--- a/nix/modules/default.nix
+++ /dev/null
@@ -1,8 +0,0 @@
-# NixOS modules for Gate services
-{ ... }:
-{
-  imports = [
-    ./tlsforward.nix
-    ./daemon.nix
-  ];
-}
\ No newline at end of file
diff --git a/nix/modules/tlsforward-colmena.nix b/nix/modules/tlsforward-colmena.nix
deleted file mode 100644
index f4221763..00000000
--- a/nix/modules/tlsforward-colmena.nix
+++ /dev/null
@@ -1,165 +0,0 @@
-{ pkgs
-, lib
-, config
-, ...
-}:
-let
-  cfg = config.services.gate-tlsforward-colmena;
-  
-  # Helper to create environment file from colmena secrets
-  mkEnvFile = name: instanceCfg: pkgs.writeScript "gate-tlsforward-${name}-env.sh" ''
-    #!/bin/sh
-    # This script generates an environment file from colmena-managed secrets
-    # It maps the old private-gate-relay variable names to the new gate-tlsforward format
-    
-    ENV_FILE="/run/gate-tlsforward-${name}/env"
-    mkdir -p "$(dirname "$ENV_FILE")"
-    
-    # Clear the file
-    : > "$ENV_FILE"
-    
-    # Map old environment variable names to new ones
-    if [ -f "${instanceCfg.cloudflareApiTokenFile}" ]; then
-      echo "RELAY__DNS__CLOUDFLARE__API_TOKEN=$(cat ${instanceCfg.cloudflareApiTokenFile})" >> "$ENV_FILE"
-    fi
-    
-    if [ -f "${instanceCfg.cloudflareZoneIdFile}" ]; then
-      echo "RELAY__DNS__CLOUDFLARE__ZONE_ID=$(cat ${instanceCfg.cloudflareZoneIdFile})" >> "$ENV_FILE"
-    fi
-    
-    # Set permissions
-    chmod 600 "$ENV_FILE"
-    chown gate-tlsforward-${name}:gate-tlsforward-${name} "$ENV_FILE"
-  '';
-in
-{
-  options.services.gate-tlsforward-colmena = {
-    enable = lib.mkEnableOption "Gate TLS Forward service with colmena secret management";
-    
-    package = lib.mkOption {
-      type = lib.types.package;
-      default = pkgs.gate-tlsforward;
-      defaultText = lib.literalExpression "pkgs.gate-tlsforward";
-      description = "The gate-tlsforward package to use";
-    };
-
-    instances = lib.mkOption {
-      type = lib.types.attrsOf (lib.types.submodule {
-        options = {
-          enable = lib.mkEnableOption "this relay instance";
-
-          httpsPort = lib.mkOption {
-            type = lib.types.port;
-            default = 8443;
-            description = "HTTPS bind port for the relay";
-          };
-
-          p2pPort = lib.mkOption {
-            type = lib.types.port;
-            default = 41146;
-            description = "P2P bind port for the relay";
-          };
-
-          metricsPort = lib.mkOption {
-            type = lib.types.nullOr lib.types.port;
-            default = null;
-            example = 9090;
-            description = "Prometheus metrics endpoint port. If null, metrics are disabled.";
-          };
-
-          logLevel = lib.mkOption {
-            type = lib.types.enum ["error" "warn" "info" "debug" "trace"];
-            default = "info";
-            description = "Log level for the relay service";
-          };
-
-          bindAddress = lib.mkOption {
-            type = lib.types.str;
-            default = "0.0.0.0";
-            description = "IP address to bind to";
-          };
-
-          domainSuffix = lib.mkOption {
-            type = lib.types.str;
-            default = "private.hellas.ai";
-            description = "Domain suffix for relay addresses";
-          };
-
-          cloudflareApiTokenFile = lib.mkOption {
-            type = lib.types.path;
-            description = "Path to file containing Cloudflare API token (typically from colmena deployment.keys)";
-          };
-
-          cloudflareZoneIdFile = lib.mkOption {
-            type = lib.types.path;
-            description = "Path to file containing Cloudflare Zone ID (typically from colmena deployment.keys)";
-          };
-
-          openFirewall = lib.mkOption {
-            type = lib.types.bool;
-            default = false;
-            description = "Open firewall ports for this instance on all interfaces";
-          };
-
-          openFirewallOnInterfaces = lib.mkOption {
-            type = lib.types.listOf lib.types.str;
-            default = [];
-            description = "List of network interfaces to open firewall ports on";
-          };
-
-          otlpEndpoint = lib.mkOption {
-            type = lib.types.nullOr lib.types.str;
-            default = null;
-            description = "OpenTelemetry endpoint for tracing (e.g. https://jaeger.example.com)";
-          };
-        };
-      });
-      default = {};
-      description = "Gate Relay instances with colmena secret management";
-    };
-  };
-
-  config = lib.mkIf cfg.enable {
-    # Enable the base gate-tlsforward service
-    services.gate-tlsforward = {
-      enable = true;
-      package = cfg.package;
-      
-      # Map colmena instances to gate-tlsforward instances
-      instances = lib.mapAttrs (name: instanceCfg: {
-        inherit (instanceCfg) enable httpsPort p2pPort metricsPort logLevel bindAddress domainSuffix openFirewall openFirewallOnInterfaces otlpEndpoint;
-        
-        # We'll dynamically generate the environment file
-        environmentFile = "/run/gate-tlsforward-${name}/env";
-        
-        dns = {
-          enabled = true;
-          provider = "cloudflare";
-        };
-      }) cfg.instances;
-    };
-    
-    # Create systemd services to generate environment files before gate-tlsforward starts
-    systemd.services = lib.mapAttrs' (name: instanceCfg:
-      lib.nameValuePair "gate-tlsforward-${name}-env" {
-        description = "Generate environment file for gate-tlsforward-${name}";
-        before = [ "gate-tlsforward-${name}.service" ];
-        requiredBy = [ "gate-tlsforward-${name}.service" ];
-        
-        serviceConfig = {
-          Type = "oneshot";
-          ExecStart = mkEnvFile name instanceCfg;
-          RemainAfterExit = true;
-          
-          # Run as root to read colmena secrets
-          User = "root";
-          Group = "root";
-          
-          # Create runtime directory
-          RuntimeDirectory = "gate-tlsforward-${name}";
-          RuntimeDirectoryMode = "0755";
-        };
-      }
-    ) (lib.filterAttrs (_: instanceCfg: instanceCfg.enable) cfg.instances);
-  };
-}
\ No newline at end of file
diff --git a/nix/modules/tlsforward.nix b/nix/modules/tlsforward.nix
deleted file mode 100644
index 33f9cbbb..00000000
--- a/nix/modules/tlsforward.nix
+++ /dev/null
@@ -1,286 +0,0 @@
-{ pkgs
-, lib
-, config
-, ...
-}:
-let
-  cfg = config.services.gate-tlsforward;
-  
-  # Helper to format socket addresses correctly (handle IPv6 brackets)
-  formatSocketAddr = addr: port:
-    if lib.hasInfix ":" addr && !lib.hasPrefix "[" addr
-    then "[${addr}]:${toString port}"
-    else "${addr}:${toString port}";
-  
-  # Generate TLS forward configuration for an instance
-  mkTlsForwardConfig = name: instanceCfg: {
-    server = {
-      log_level = instanceCfg.logLevel;
-      metrics_addr = if instanceCfg.metricsPort != null 
-        then formatSocketAddr instanceCfg.bindAddress instanceCfg.metricsPort
-        else null;
-    };
-    p2p = {
-      bind_addrs = if instanceCfg.bindAddress == "::" || instanceCfg.bindAddress == "0.0.0.0"
-        then [ 
-          "[::]:${toString instanceCfg.p2pPort}"
-          "0.0.0.0:${toString instanceCfg.p2pPort}"
-        ]
-        else [ (formatSocketAddr instanceCfg.bindAddress instanceCfg.p2pPort) ];
-      secret_key_path = "/var/lib/gate-tlsforward-${name}/keys/secret";
-      enable_discovery = true;
-    };
-    https_proxy = {
-      bind_addr = formatSocketAddr instanceCfg.bindAddress instanceCfg.httpsPort;
-      domain_suffix = instanceCfg.domainSuffix;
-      max_connections = 1000;
-      connection_timeout_secs = 30;
-    };
-    dns = {
-      enabled = instanceCfg.dns.enabled;
-      provider = instanceCfg.dns.provider;
-      cloudflare = {
-        # API token and zone ID come from environment
-      };
-    };
-  };
-  
-  # Helper to create instance configurations
-  mkInstance = name: instanceCfg: 
-    let
-      serviceName = "gate-tlsforward-${name}";
-      userName = "gate-tlsforward-${name}";
-      bindAddr = formatSocketAddr instanceCfg.bindAddress instanceCfg.httpsPort;
-      p2pBindAddr = formatSocketAddr instanceCfg.bindAddress instanceCfg.p2pPort;
-      stateDir = "/var/lib/gate-tlsforward-${name}";
-      configFile = (pkgs.formats.json {}).generate "gate-tlsforward-${name}-config.json" (mkTlsForwardConfig name instanceCfg);
-    in {
-      inherit serviceName userName bindAddr p2pBindAddr stateDir configFile;
-      config = instanceCfg;
-    };
-in
-{
-  options.services.gate-tlsforward = {
-    enable = lib.mkEnableOption "Gate TLS Forward service";
-    
-    package = lib.mkOption {
-      type = lib.types.package;
-      default = pkgs.gate-tlsforward;
-      defaultText = lib.literalExpression "pkgs.gate-tlsforward";
-      description = "The gate-tlsforward package to use";
-    };
-
-    instances = lib.mkOption {
-      type = lib.types.attrsOf (lib.types.submodule {
-        options = {
-          enable = lib.mkEnableOption "this TLS forward instance";
-
-          httpsPort = lib.mkOption {
-            type = lib.types.port;
-            default = 8443;
-            description = "HTTPS bind port for the TLS forward service";
-          };
-
-          p2pPort = lib.mkOption {
-            type = lib.types.port;
-            default = 41146;
-            description = "P2P bind port for the TLS forward service";
-          };
-
-          metricsPort = lib.mkOption {
-            type = lib.types.nullOr lib.types.port;
-            default = null;
-            example = 9090;
-            description = "Prometheus metrics endpoint port. If null, metrics are disabled.";
-          };
-
-          logLevel = lib.mkOption {
-            type = lib.types.enum ["error" "warn" "info" "debug" "trace"];
-            default = "info";
-            description = "Log level for the TLS forward service";
-          };
-
-          bindAddress = lib.mkOption {
-            type = lib.types.str;
-            default = "0.0.0.0";
-            description = "IP address to bind to";
-          };
-
-          domainSuffix = lib.mkOption {
-            type = lib.types.str;
-            default = "gate.hellas.ai";
-            description = "Domain suffix for TLS forward addresses";
-          };
-
-          dns = lib.mkOption {
-            type = lib.types.submodule {
-              options = {
-                enabled = lib.mkOption {
-                  type = lib.types.bool;
-                  default = true;
-                  description = "Enable DNS record management";
-                };
-
-                provider = lib.mkOption {
-                  type = lib.types.enum ["cloudflare"];
-                  default = "cloudflare";
-                  description = "DNS provider for record management";
-                };
-              };
-            };
-            default = {};
-            description = "DNS configuration";
-          };
-
-          otlpEndpoint = lib.mkOption {
-            type = lib.types.nullOr lib.types.str;
-            default = null;
-            example = "http://localhost:4318";
-            description = ''
-              OpenTelemetry Protocol (OTLP) endpoint for exporting traces.
-              If set, enables trace export to Jaeger or other OTLP collectors.
-            '';
-          };
-
-          environmentFile = lib.mkOption {
-            type = lib.types.nullOr lib.types.path;
-            default = null;
-            description = ''
-              Path to environment file containing secrets.
-              Should define:
-              - TLSFORWARD__DNS__CLOUDFLARE__API_TOKEN
-              - TLSFORWARD__DNS__CLOUDFLARE__ZONE_ID
-            '';
-          };
-
-          openFirewall = lib.mkOption {
-            type = lib.types.bool;
-            default = false;
-            description = "Open firewall ports for this instance on all interfaces";
-          };
-
-          openFirewallOnInterfaces = lib.mkOption {
-            type = lib.types.listOf lib.types.str;
-            default = [];
-            description = "List of network interfaces to open firewall ports on";
-          };
-        };
-      });
-      default = {};
-      description = "Gate TLS Forward instances";
-    };
-  };
-
-  config = lib.mkIf cfg.enable {
-    # Create users and groups for each instance
-    users.groups = lib.mapAttrs' (name: instanceCfg:
-      lib.nameValuePair "gate-tlsforward-${name}" {}
-    ) (lib.filterAttrs (_: instanceCfg: instanceCfg.enable) cfg.instances);
-
-    users.users = lib.mapAttrs' (name: instanceCfg:
-      lib.nameValuePair "gate-tlsforward-${name}" {
-        isSystemUser = true;
-        group = "gate-tlsforward-${name}";
-        home = "/var/lib/gate-tlsforward-${name}";
-        createHome = true;
-      }
-    ) (lib.filterAttrs (_: instanceCfg: instanceCfg.enable) cfg.instances);
-
-    # Create systemd services for each instance
-    systemd.services = lib.mapAttrs' (name: instanceCfg:
-      let
-        instance = mkInstance name instanceCfg;
-      in
-      lib.nameValuePair instance.serviceName {
-        description = "Gate TLS Forward service (${name})";
-        after = [ "network-online.target" ];
-        wants = [ "network-online.target" ];
-        wantedBy = [ "multi-user.target" ];
-
-        serviceConfig = {
-          Type = "exec";
-          User = instance.userName;
-          Group = instance.userName;
-          ExecStart = "${cfg.package}/bin/gate-tlsforward -c ${instance.configFile}";
-          
-          Environment = [
-            "RUST_LOG=${instanceCfg.logLevel}"
-            "GATE_STATE_DIR=${instance.stateDir}"
-          ] ++ lib.optional (instanceCfg.otlpEndpoint != null) "OTLP_ENDPOINT=${instanceCfg.otlpEndpoint}";
-          
-          EnvironmentFile = lib.optional (instanceCfg.environmentFile != null) instanceCfg.environmentFile;
-          
-          # State directory management
-          StateDirectory = "gate-tlsforward-${name}";
-          StateDirectoryMode = "0755";
-          
-          # Logging
-          StandardOutput = "journal";
-          StandardError = "journal";
-          WorkingDirectory = instance.stateDir;
-          
-          # Restart behavior
-          Restart = "on-failure";
-          RestartSec = "5s";
-          StartLimitBurst = 3;
-          StartLimitIntervalSec = "1m";
-          
-          # Security hardening
-          NoNewPrivileges = true;
-          ProtectSystem = "strict";
-          ProtectHome = true;  
-          PrivateTmp = true;
-          PrivateDevices = true;  
-          ProtectHostname = true;
-          ProtectClock = true;
-          ProtectKernelTunables = true;
-          ProtectKernelModules = true;
-          ProtectKernelLogs = true;
-          ProtectControlGroups = true;
-          RestrictNamespaces = true;
-          LockPersonality = true;
-          MemoryDenyWriteExecute = true;
-          RestrictRealtime = true;
-          RestrictSUIDSGID = true;
-          RemoveIPC = true;
-          
-          # Network capabilities for binding and interface management
-          AmbientCapabilities = [ "CAP_NET_BIND_SERVICE" "CAP_NET_RAW" "CAP_NET_ADMIN" ];
-          CapabilityBoundingSet = [ "CAP_NET_BIND_SERVICE" "CAP_NET_RAW" "CAP_NET_ADMIN" ];
-        };
-      }
-    ) (lib.filterAttrs (_: instanceCfg: instanceCfg.enable) cfg.instances);
-
-    # Configure firewall for enabled instances
-    networking.firewall = 
-      let
-        enabledInstances = lib.filterAttrs (_: instanceCfg: instanceCfg.enable) cfg.instances;
-        
-        # Instances that want all interfaces
-        globalInstances = lib.filterAttrs (_: instanceCfg: instanceCfg.openFirewall) enabledInstances;
-        globalTcpPorts = lib.flatten (lib.mapAttrsToList (_: instanceCfg: 
-          [instanceCfg.httpsPort instanceCfg.p2pPort] ++ lib.optional (instanceCfg.metricsPort != null) instanceCfg.metricsPort
-        ) globalInstances);
-        globalUdpPorts = lib.flatten (lib.mapAttrsToList (_: instanceCfg: [instanceCfg.p2pPort]) globalInstances);
-        
-        # Instances that want specific interfaces
-        interfaceInstances = lib.filterAttrs (_: instanceCfg: instanceCfg.openFirewallOnInterfaces != []) enabledInstances;
-        interfaceConfigs = lib.foldl (acc: instanceCfg:
-          lib.foldl (acc2: iface:
-            acc2 // {
-              ${iface} = (acc2.${iface} or {}) // {
-                allowedTCPPorts = (acc2.${iface}.allowedTCPPorts or []) ++ 
-                  [instanceCfg.httpsPort instanceCfg.p2pPort] ++ lib.optional (instanceCfg.metricsPort != null) instanceCfg.metricsPort;
-                allowedUDPPorts = (acc2.${iface}.allowedUDPPorts or []) ++ [instanceCfg.p2pPort];
-              };
-            }
-          ) acc instanceCfg.openFirewallOnInterfaces
-        ) {} (lib.attrValues interfaceInstances);
-      in
-      {
-        allowedTCPPorts = globalTcpPorts;
-        allowedUDPPorts = globalUdpPorts;
-        interfaces = interfaceConfigs;
-      };
-  };
-}
\ No newline at end of file
diff --git a/nix/overlay.nix b/nix/overlay.nix
deleted file mode 100644
index 7f3eb900..00000000
--- a/nix/overlay.nix
+++ /dev/null
@@ -1,14 +0,0 @@
-# Overlay that adds gate packages to nixpkgs
-self: final: prev:
-let
-  # Only add packages if they exist for this system
-  gatePackages = self.packages.${final.system} or {};
-in
-{
-  gate-daemon = gatePackages.gate-daemon or null;
-  gate-tlsforward = gatePackages.gate-tlsforward or null;
-  gate-frontend-daemon = gatePackages.gate-frontend-daemon or null;
-  gate-frontend-tauri = gatePackages.gate-frontend-tauri or null;
-  gate-frontend-relay = gatePackages.gate-frontend-relay or null;
-  gate = gatePackages.gate or null;
-}
\ No newline at end of file
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 1e79476c..9d83358f 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,5 +1,4 @@
 [toolchain]
-channel = "nightly-2025-06-10"
+channel = "1.96.1"
 components = ["rustfmt", "clippy", "rust-src", "rust-analyzer"]
-targets = ["wasm32-unknown-unknown", "aarch64-apple-darwin", "x86_64-apple-darwin", "aarch64-unknown-linux-gnu", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "x86_64-pc-windows-gnu"]
 profile = "minimal"
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
new file mode 100644
index 00000000..04f09ff0
--- /dev/null
+++ b/src-tauri/Cargo.toml
@@ -0,0 +1,44 @@
+[package]
+name = "hellas-gate"
+description = "The native desktop host for Hellas"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+license.workspace = true
+repository.workspace = true
+
+[features]
+default = ["desktop"]
+desktop = ["dep:tauri", "dep:tauri-build", "dep:ts-rs"]
+
+[lib]
+path = "src/lib.rs"
+
+[[bin]]
+name = "hellas-gate"
+path = "src/main.rs"
+required-features = ["desktop"]
+
+[dependencies]
+anyhow = "1"
+futures = "0.3"
+hellas-attestation = { path = "../../hellas/crates/attestation", features = ["apple-app-attest"] }
+hellas-rpc = { path = "../../hellas/crates/rpc", features = ["host-control", "execute", "fetch", "courtesy"] }
+hellas-sdk = { path = "../../hellas/crates/sdk", default-features = false, features = ["apple-verifier", "client", "gateway", "local-control", "provider"] }
+hellas-wire = { path = "../../hellas/crates/wire", features = ["unix"] }
+libc = "0.2"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tauri = { version = "2", features = ["tray-icon"], optional = true }
+tempfile = "3"
+thiserror = "2"
+tokio = { version = "1", features = ["macros", "rt-multi-thread", "sync", "net", "fs", "time"] }
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+ts-rs = { version = "12", features = ["serde-compat"], optional = true }
+
+[build-dependencies]
+tauri-build = { version = "2", features = [], optional = true }
+
+[target.'cfg(target_os = "macos")'.build-dependencies]
+cc = "1"
diff --git a/src-tauri/build.rs b/src-tauri/build.rs
new file mode 100644
index 00000000..65837b49
--- /dev/null
+++ b/src-tauri/build.rs
@@ -0,0 +1,15 @@
+fn main() {
+    #[cfg(target_os = "macos")]
+    {
+        cc::Build::new()
+            .file("src/apple_app_attest.m")
+            .flag("-fobjc-arc")
+            .flag("-fblocks")
+            .compile("gate_apple_app_attest");
+        println!("cargo:rustc-link-lib=framework=DeviceCheck");
+        println!("cargo:rustc-link-lib=framework=Foundation");
+        println!("cargo:rustc-link-lib=framework=Security");
+    }
+    #[cfg(feature = "desktop")]
+    tauri_build::build();
+}
diff --git a/src-tauri/src/apple.rs b/src-tauri/src/apple.rs
new file mode 100644
index 00000000..5ef9dc4e
--- /dev/null
+++ b/src-tauri/src/apple.rs
@@ -0,0 +1,207 @@
+pub struct Availability {
+    pub label: &'static str,
+    pub detail: &'static str,
+}
+
+#[cfg(target_os = "macos")]
+pub fn availability() -> Availability {
+    if unsafe { hellas_apple_supported() } {
+        Availability {
+            label: "available",
+            detail: "App Attest is available; enrollment has not been created",
+        }
+    } else {
+        Availability {
+            label: "unavailable",
+            detail: "App Attest is unavailable to this build or machine",
+        }
+    }
+}
+
+#[cfg(not(target_os = "macos"))]
+pub const fn availability() -> Availability {
+    Availability {
+        label: "unavailable",
+        detail: "App Attest is available only in a provisioned macOS Gate build",
+    }
+}
+
+#[cfg(target_os = "macos")]
+mod native {
+    use std::ffi::{CStr, CString, c_char};
+
+    use hellas_attestation::{
+        AppleCredential, AttestationError, Attester, Binding, RootProver, apple_client_data_hash,
+    };
+    use hellas_rpc::pb::execute::AssuranceEvidence;
+    use hellas_rpc::{APPLE_APP_ATTEST, ContentId, Digest, RootProof};
+
+    #[derive(Clone)]
+    pub struct AppleAppAttestRoot {
+        key: String,
+        credential: ContentId,
+    }
+
+    impl AppleAppAttestRoot {
+        pub fn create(
+            enrollment_statement: &[u8],
+        ) -> Result<(Self, AppleCredential), AttestationError> {
+            if !unsafe { super::hellas_apple_supported() } {
+                return Err(AttestationError::Platform("unavailable to this app".into()));
+            }
+            let key = String::from_utf8(call(unsafe { hellas_apple_generate_key() })?)
+                .map_err(|_| AttestationError::Platform("invalid key identifier".into()))?;
+            let hash = apple_client_data_hash(enrollment_statement);
+            let attestation =
+                call(unsafe { hellas_apple_attest(cstring(&key)?.as_ptr(), hash.as_ptr()) })?;
+            let credential = AppleCredential {
+                attestation,
+                client_data_hash: hash,
+            };
+            Ok((
+                Self {
+                    key,
+                    credential: credential.content_id(),
+                },
+                credential,
+            ))
+        }
+
+        pub fn load(key: String, credential: ContentId) -> Self {
+            Self { key, credential }
+        }
+
+        pub fn key(&self) -> &str {
+            &self.key
+        }
+
+        fn assertion(&self, hash: [u8; 32]) -> Result<Vec<u8>, AttestationError> {
+            call(unsafe { hellas_apple_assert(cstring(&self.key)?.as_ptr(), hash.as_ptr()) })
+        }
+
+        async fn assertion_async(&self, hash: [u8; 32]) -> Result<Vec<u8>, AttestationError> {
+            let root = self.clone();
+            tokio::task::spawn_blocking(move || root.assertion(hash))
+                .await
+                .map_err(|error| AttestationError::Platform(error.to_string()))?
+        }
+    }
+
+    impl Attester for AppleAppAttestRoot {
+        async fn attest(&self, binding: Binding) -> Result<AssuranceEvidence, AttestationError> {
+            Ok(AssuranceEvidence {
+                codec: APPLE_APP_ATTEST.into(),
+                credential: self.credential.as_bytes().to_vec(),
+                proof: self.assertion_async(*binding.as_bytes()).await?,
+            })
+        }
+    }
+
+    impl RootProver for AppleAppAttestRoot {
+        async fn prove_statement(&self, statement: &[u8]) -> Result<RootProof, AttestationError> {
+            Ok(RootProof::AppleAppAttest(
+                self.assertion_async(apple_client_data_hash(statement))
+                    .await?,
+            ))
+        }
+
+        async fn prove_open_binding(&self, binding: Digest) -> Result<RootProof, AttestationError> {
+            Ok(RootProof::AppleAppAttest(
+                self.assertion_async(*binding.as_bytes()).await?,
+            ))
+        }
+    }
+
+    #[repr(C)]
+    struct NativeResult {
+        bytes: *mut u8,
+        len: usize,
+        error: *mut c_char,
+    }
+
+    fn cstring(value: &str) -> Result<CString, AttestationError> {
+        CString::new(value).map_err(|_| AttestationError::Platform("invalid key identifier".into()))
+    }
+
+    fn call(value: NativeResult) -> Result<Vec<u8>, AttestationError> {
+        let result = if value.error.is_null() {
+            if value.len == 0 {
+                Ok(Vec::new())
+            } else if value.bytes.is_null() {
+                Err(AttestationError::Platform(
+                    "DeviceCheck returned an invalid empty result".into(),
+                ))
+            } else {
+                Ok(unsafe { std::slice::from_raw_parts(value.bytes, value.len) }.to_vec())
+            }
+        } else {
+            Err(AttestationError::Platform(
+                unsafe { CStr::from_ptr(value.error) }
+                    .to_string_lossy()
+                    .into_owned(),
+            ))
+        };
+        unsafe { hellas_apple_result_free(value) };
+        result
+    }
+
+    unsafe extern "C" {
+        fn hellas_apple_generate_key() -> NativeResult;
+        fn hellas_apple_attest(key: *const c_char, hash: *const u8) -> NativeResult;
+        fn hellas_apple_assert(key: *const c_char, hash: *const u8) -> NativeResult;
+        fn hellas_apple_result_free(value: NativeResult);
+    }
+}
+
+#[cfg(target_os = "macos")]
+pub use native::AppleAppAttestRoot;
+
+#[cfg(not(target_os = "macos"))]
+#[derive(Clone)]
+pub struct AppleAppAttestRoot;
+
+#[cfg(not(target_os = "macos"))]
+impl AppleAppAttestRoot {
+    pub fn create(
+        _enrollment_statement: &[u8],
+    ) -> Result<(Self, hellas_attestation::AppleCredential), hellas_attestation::AttestationError>
+    {
+        Err(hellas_attestation::AttestationError::Platform(
+            "unavailable outside a provisioned macOS Gate build".into(),
+        ))
+    }
+
+    pub fn load(_key: String, _credential: hellas_rpc::ContentId) -> Self {
+        Self
+    }
+
+    pub fn key(&self) -> &str {
+        ""
+    }
+}
+
+#[cfg(not(target_os = "macos"))]
+impl hellas_attestation::RootProver for AppleAppAttestRoot {
+    async fn prove_statement(
+        &self,
+        _statement: &[u8],
+    ) -> Result<hellas_rpc::RootProof, hellas_attestation::AttestationError> {
+        Err(hellas_attestation::AttestationError::Platform(
+            "Apple App Attest is unavailable".into(),
+        ))
+    }
+
+    async fn prove_open_binding(
+        &self,
+        _binding: hellas_rpc::Digest,
+    ) -> Result<hellas_rpc::RootProof, hellas_attestation::AttestationError> {
+        Err(hellas_attestation::AttestationError::Platform(
+            "Apple App Attest is unavailable".into(),
+        ))
+    }
+}
+
+#[cfg(target_os = "macos")]
+unsafe extern "C" {
+    fn hellas_apple_supported() -> bool;
+}
diff --git a/src-tauri/src/apple_app_attest.m b/src-tauri/src/apple_app_attest.m
new file mode 100644
index 00000000..859b8f52
--- /dev/null
+++ b/src-tauri/src/apple_app_attest.m
@@ -0,0 +1,104 @@
+#import <DeviceCheck/DeviceCheck.h>
+#import <Security/SecTask.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+    uint8_t *bytes;
+    size_t len;
+    char *error;
+} HellasAppleResult;
+
+static HellasAppleResult result(NSData *data, NSError *error) {
+    HellasAppleResult out = {0};
+    if (error) {
+        const char *text = error.localizedDescription.UTF8String;
+        out.error = strdup(text ?: "unknown error");
+    } else if (data) {
+        out.len = data.length;
+        out.bytes = malloc(out.len);
+        if (out.len > 0 && !out.bytes) {
+            out.len = 0;
+            out.error = strdup("allocating DeviceCheck result failed");
+        } else if (out.len > 0) {
+            memcpy(out.bytes, data.bytes, out.len);
+        }
+    } else {
+        out.error = strdup("DeviceCheck returned neither data nor an error");
+    }
+    return out;
+}
+
+static void await(dispatch_semaphore_t done) {
+    while (dispatch_semaphore_wait(done, DISPATCH_TIME_NOW))
+        [NSRunLoop.currentRunLoop runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.01]];
+}
+
+bool hellas_apple_supported(void) {
+    NSString *profile = [NSBundle.mainBundle.bundlePath
+        stringByAppendingPathComponent:@"Contents/embedded.provisionprofile"];
+    if (![NSFileManager.defaultManager fileExistsAtPath:profile])
+        return false;
+
+    SecTaskRef task = SecTaskCreateFromSelf(NULL);
+    if (!task)
+        return false;
+    CFTypeRef value = SecTaskCopyValueForEntitlement(
+        task,
+        CFSTR("com.apple.developer.devicecheck.app-attest-opt-in"),
+        NULL);
+    bool entitled = value && CFGetTypeID(value) == CFArrayGetTypeID()
+        && CFArrayContainsValue(
+            value,
+            CFRangeMake(0, CFArrayGetCount(value)),
+            CFSTR("CDhash"));
+    if (value)
+        CFRelease(value);
+    CFRelease(task);
+
+    return entitled && DCAppAttestService.sharedService.supported;
+}
+
+HellasAppleResult hellas_apple_generate_key(void) {
+    dispatch_semaphore_t done = dispatch_semaphore_create(0);
+    __block HellasAppleResult out;
+    [DCAppAttestService.sharedService generateKeyWithCompletionHandler:^(NSString *key, NSError *error) {
+        out = result([key dataUsingEncoding:NSUTF8StringEncoding], error);
+        dispatch_semaphore_signal(done);
+    }];
+    await(done);
+    return out;
+}
+
+HellasAppleResult hellas_apple_attest(const char *key, const uint8_t hash[32]) {
+    dispatch_semaphore_t done = dispatch_semaphore_create(0);
+    __block HellasAppleResult out;
+    NSData *client = [NSData dataWithBytes:hash length:32];
+    NSString *identifier = [NSString stringWithUTF8String:key];
+    [DCAppAttestService.sharedService attestKey:identifier clientDataHash:client completionHandler:^(NSData *attestation, NSError *error) {
+        out = result(attestation, error);
+        dispatch_semaphore_signal(done);
+    }];
+    await(done);
+    return out;
+}
+
+HellasAppleResult hellas_apple_assert(const char *key, const uint8_t hash[32]) {
+    dispatch_semaphore_t done = dispatch_semaphore_create(0);
+    __block HellasAppleResult out;
+    NSData *client = [NSData dataWithBytes:hash length:32];
+    NSString *identifier = [NSString stringWithUTF8String:key];
+    [DCAppAttestService.sharedService generateAssertion:identifier clientDataHash:client completionHandler:^(NSData *assertion, NSError *error) {
+        out = result(assertion, error);
+        dispatch_semaphore_signal(done);
+    }];
+    await(done);
+    return out;
+}
+
+void hellas_apple_result_free(HellasAppleResult value) {
+    free(value.bytes);
+    free(value.error);
+}
diff --git a/src-tauri/src/commands.rs b/src-tauri/src/commands.rs
new file mode 100644
index 00000000..5e244361
--- /dev/null
+++ b/src-tauri/src/commands.rs
@@ -0,0 +1,204 @@
+use std::sync::Arc;
+
+use futures::StreamExt;
+use tauri::State;
+use tauri::ipc::Channel;
+
+use crate::dto::{
+    AppStatus, ExecutionEvent, GatewayAccess, HistoryEntry, ProviderConfig, RunRequest,
+};
+use crate::error::{ApiError, ApiResult};
+use crate::state::AppState;
+
+#[tauri::command]
+pub async fn get_status(state: State<'_, Arc<AppState>>) -> ApiResult<AppStatus> {
+    Ok(state.status().await)
+}
+
+#[tauri::command]
+pub async fn set_provider_enabled(
+    state: State<'_, Arc<AppState>>,
+    enabled: bool,
+    config: Option<ProviderConfig>,
+) -> ApiResult<AppStatus> {
+    state
+        .set_provider_enabled(enabled, config)
+        .await
+        .map_err(ApiError::internal)
+}
+
+#[tauri::command]
+pub async fn set_gateway_enabled(
+    state: State<'_, Arc<AppState>>,
+    enabled: bool,
+    config: Option<RunRequest>,
+) -> ApiResult<AppStatus> {
+    state
+        .set_gateway_enabled(enabled, config)
+        .await
+        .map_err(ApiError::internal)
+}
+
+#[tauri::command]
+pub async fn get_gateway_access(state: State<'_, Arc<AppState>>) -> ApiResult<GatewayAccess> {
+    state
+        .gateway_access()
+        .await
+        .ok_or_else(|| ApiError::new("gateway_stopped", "The loopback gateway is not running"))
+}
+
+#[tauri::command]
+pub async fn run_request(
+    state: State<'_, Arc<AppState>>,
+    request: RunRequest,
+    on_event: Channel<ExecutionEvent>,
+) -> ApiResult<String> {
+    if request.input.trim().is_empty() {
+        return Err(ApiError::new("invalid_request", "Input cannot be empty"));
+    }
+    if request.target.trim().is_empty() || request.trust_anchor.trim().is_empty() {
+        return Err(ApiError::new(
+            "trust_required",
+            "A target and explicit trust anchor are required",
+        ));
+    }
+
+    let run_id = state.history.begin(&request).map_err(ApiError::internal)?;
+    on_event
+        .send(ExecutionEvent::Started {
+            run_id: run_id.clone(),
+        })
+        .map_err(ApiError::internal)?;
+
+    let mut stream = match state.fetch(&request).await {
+        Ok(stream) => stream,
+        Err(error) => {
+            let message = error.to_string();
+            state
+                .history
+                .fail(&run_id, &message)
+                .map_err(ApiError::internal)?;
+            on_event
+                .send(ExecutionEvent::Failed {
+                    run_id: run_id.clone(),
+                    message,
+                })
+                .map_err(ApiError::internal)?;
+            return Ok(run_id);
+        }
+    };
+
+    while let Some(event) = stream.next().await {
+        match event {
+            Ok(hellas_sdk::client::FetchExecutionEvent::Chunk { event, .. }) => {
+                let record = serde_json::to_string(&event).map_err(ApiError::internal)?;
+                let text = render_output_event(&event).map_err(ApiError::internal)?;
+                state
+                    .history
+                    .append_result(&run_id, &record)
+                    .map_err(ApiError::internal)?;
+                on_event
+                    .send(ExecutionEvent::Output { text })
+                    .map_err(ApiError::internal)?;
+            }
+            Ok(hellas_sdk::client::FetchExecutionEvent::Done(
+                hellas_sdk::client::FetchOutcome::Completed { terminal, .. },
+            )) => {
+                let text = serde_json::to_string(&terminal.to_output_event())
+                    .map_err(ApiError::internal)?;
+                let verification =
+                    "Provider identity, signatures, commitments, and Fetch transcript verified";
+                state
+                    .history
+                    .append_result(&run_id, &text)
+                    .and_then(|()| state.history.complete(&run_id, verification))
+                    .map_err(ApiError::internal)?;
+                on_event
+                    .send(ExecutionEvent::Output { text })
+                    .and_then(|()| {
+                        on_event.send(ExecutionEvent::Verification {
+                            summary: verification.into(),
+                        })
+                    })
+                    .and_then(|()| {
+                        on_event.send(ExecutionEvent::Finished {
+                            run_id: run_id.clone(),
+                        })
+                    })
+                    .map_err(ApiError::internal)?;
+                return Ok(run_id);
+            }
+            Ok(hellas_sdk::client::FetchExecutionEvent::Done(
+                hellas_sdk::client::FetchOutcome::Failed { position, error },
+            )) => {
+                let message = format!("Fetch failed at byte {position}: {error}");
+                state
+                    .history
+                    .fail(&run_id, &message)
+                    .map_err(ApiError::internal)?;
+                on_event
+                    .send(ExecutionEvent::Failed {
+                        run_id: run_id.clone(),
+                        message,
+                    })
+                    .map_err(ApiError::internal)?;
+                return Ok(run_id);
+            }
+            Err(error) => {
+                let message = error.to_string();
+                state
+                    .history
+                    .fail(&run_id, &message)
+                    .map_err(ApiError::internal)?;
+                on_event
+                    .send(ExecutionEvent::Failed {
+                        run_id: run_id.clone(),
+                        message,
+                    })
+                    .map_err(ApiError::internal)?;
+                return Ok(run_id);
+            }
+        }
+    }
+
+    let message = "Fetch stream ended without a terminal outcome";
+    state
+        .history
+        .fail(&run_id, message)
+        .map_err(ApiError::internal)?;
+    on_event
+        .send(ExecutionEvent::Failed {
+            run_id: run_id.clone(),
+            message: message.into(),
+        })
+        .map_err(ApiError::internal)?;
+    Ok(run_id)
+}
+
+fn render_output_event(event: &hellas_rpc::output::OutputEvent) -> serde_json::Result<String> {
+    match event {
+        hellas_rpc::output::OutputEvent::TextDelta { delta, .. } => Ok(delta.clone()),
+        _ => Ok(format!("{}\n", serde_json::to_string(event)?)),
+    }
+}
+
+#[tauri::command]
+pub async fn list_history(
+    state: State<'_, Arc<AppState>>,
+    limit: Option<u32>,
+) -> ApiResult<Vec<HistoryEntry>> {
+    state
+        .history
+        .list(limit.unwrap_or(100))
+        .map_err(ApiError::internal)
+}
+
+#[tauri::command]
+pub async fn delete_history(state: State<'_, Arc<AppState>>, id: String) -> ApiResult<bool> {
+    state.history.delete(&id).map_err(ApiError::internal)
+}
+
+#[tauri::command]
+pub async fn clear_history(state: State<'_, Arc<AppState>>) -> ApiResult<usize> {
+    state.history.clear().map_err(ApiError::internal)
+}
diff --git a/src-tauri/src/dto.rs b/src-tauri/src/dto.rs
new file mode 100644
index 00000000..47379a75
--- /dev/null
+++ b/src-tauri/src/dto.rs
@@ -0,0 +1,174 @@
+use serde::{Deserialize, Serialize};
+#[cfg(feature = "desktop")]
+use ts_rs::TS;
+
+#[derive(Clone, Debug, Serialize)]
+#[cfg_attr(feature = "desktop", derive(TS))]
+#[cfg_attr(feature = "desktop", ts(export))]
+#[serde(rename_all = "camelCase")]
+pub struct ServiceStatus {
+    pub state: ServiceState,
+    pub detail: String,
+}
+
+#[derive(Clone, Copy, Debug, Serialize)]
+#[cfg_attr(feature = "desktop", derive(TS))]
+#[cfg_attr(feature = "desktop", ts(export))]
+#[serde(rename_all = "camelCase")]
+pub enum ServiceState {
+    Stopped,
+    Starting,
+    Running,
+    Stopping,
+    Failed,
+}
+
+#[derive(Clone, Debug, Serialize)]
+#[cfg_attr(feature = "desktop", derive(TS))]
+#[cfg_attr(feature = "desktop", ts(export))]
+#[serde(rename_all = "camelCase")]
+pub struct IdentityStatus {
+    pub producer_id: String,
+    pub caller_public_key: String,
+    pub node_id: String,
+    pub attestation: String,
+    pub detail: String,
+}
+
+#[derive(Clone, Debug, Serialize)]
+#[cfg_attr(feature = "desktop", derive(TS))]
+#[cfg_attr(feature = "desktop", ts(export))]
+#[serde(rename_all = "camelCase")]
+pub struct AppStatus {
+    pub version: String,
+    pub identity: IdentityStatus,
+    pub provider: ServiceStatus,
+    pub gateway: ServiceStatus,
+    pub endpoint: String,
+    pub socket_path: String,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[cfg_attr(feature = "desktop", derive(TS))]
+#[cfg_attr(feature = "desktop", ts(export))]
+#[serde(rename_all = "camelCase")]
+pub struct RunRequest {
+    pub kind: RunKind,
+    pub target: String,
+    #[serde(default)]
+    pub node_addresses: Vec<String>,
+    pub input: String,
+    pub trust_anchor: String,
+    #[serde(default)]
+    pub service: String,
+    #[serde(default)]
+    pub method: String,
+    #[serde(default)]
+    pub execution_environment: String,
+    #[serde(default)]
+    pub assurance: AssuranceInput,
+    #[serde(default)]
+    pub apple_app_id: String,
+    #[serde(default)]
+    pub apple_cd_hashes: Vec<String>,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Serialize)]
+#[cfg_attr(feature = "desktop", derive(TS))]
+#[cfg_attr(feature = "desktop", ts(export))]
+#[serde(rename_all = "camelCase")]
+pub enum RunKind {
+    CausalLm,
+    Fetch,
+}
+
+#[derive(Clone, Copy, Debug, Default, Deserialize, Serialize)]
+#[cfg_attr(feature = "desktop", derive(TS))]
+#[cfg_attr(feature = "desktop", ts(export))]
+#[serde(rename_all = "camelCase")]
+pub enum AssuranceInput {
+    #[default]
+    ProducerSigned,
+    AppleAppAttest,
+}
+
+#[derive(Clone, Debug, Serialize)]
+#[cfg_attr(feature = "desktop", derive(TS))]
+#[cfg_attr(feature = "desktop", ts(export))]
+#[serde(
+    tag = "type",
+    content = "data",
+    rename_all = "camelCase",
+    rename_all_fields = "camelCase"
+)]
+pub enum ExecutionEvent {
+    Started { run_id: String },
+    Output { text: String },
+    Verification { summary: String },
+    Finished { run_id: String },
+    Failed { run_id: String, message: String },
+}
+
+#[derive(Clone, Debug, Serialize)]
+#[cfg_attr(feature = "desktop", derive(TS))]
+#[cfg_attr(feature = "desktop", ts(export))]
+#[serde(rename_all = "camelCase")]
+pub struct HistoryEntry {
+    pub id: String,
+    pub created_at_ms: i64,
+    pub kind: String,
+    pub target: String,
+    pub status: String,
+    pub request: String,
+    pub result: String,
+    pub verification: String,
+    pub error: String,
+}
+
+#[derive(Clone, Debug, Serialize)]
+#[cfg_attr(feature = "desktop", derive(TS))]
+#[cfg_attr(feature = "desktop", ts(export))]
+#[serde(rename_all = "camelCase")]
+pub struct GatewayAccess {
+    pub address: String,
+    pub bearer: String,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[cfg_attr(feature = "desktop", derive(TS))]
+#[cfg_attr(feature = "desktop", ts(export))]
+#[serde(rename_all = "camelCase")]
+pub struct ProviderConfig {
+    pub service: String,
+    pub method: String,
+    pub openai_api_key: String,
+    #[serde(default)]
+    pub allowed_callers: Vec<String>,
+    #[cfg_attr(feature = "desktop", ts(optional))]
+    pub port: Option<u16>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ExecutionEvent;
+
+    #[test]
+    fn execution_events_expose_the_run_id_expected_by_the_ui() {
+        for event in [
+            ExecutionEvent::Started {
+                run_id: "run-1".into(),
+            },
+            ExecutionEvent::Finished {
+                run_id: "run-1".into(),
+            },
+            ExecutionEvent::Failed {
+                run_id: "run-1".into(),
+                message: "failed".into(),
+            },
+        ] {
+            let value = serde_json::to_value(event).unwrap();
+            assert_eq!(value["data"]["runId"], "run-1");
+            assert!(value["data"].get("run_id").is_none());
+        }
+    }
+}
diff --git a/src-tauri/src/error.rs b/src-tauri/src/error.rs
new file mode 100644
index 00000000..1497bf04
--- /dev/null
+++ b/src-tauri/src/error.rs
@@ -0,0 +1,27 @@
+use serde::Serialize;
+#[cfg(feature = "desktop")]
+use ts_rs::TS;
+
+#[derive(Clone, Debug, Serialize)]
+#[cfg_attr(feature = "desktop", derive(TS))]
+#[cfg_attr(feature = "desktop", ts(export))]
+#[serde(rename_all = "camelCase")]
+pub struct ApiError {
+    pub code: &'static str,
+    pub message: String,
+}
+
+impl ApiError {
+    pub fn new(code: &'static str, message: impl Into<String>) -> Self {
+        Self {
+            code,
+            message: message.into(),
+        }
+    }
+
+    pub fn internal(error: impl std::fmt::Display) -> Self {
+        Self::new("internal", error.to_string())
+    }
+}
+
+pub type ApiResult<T> = Result<T, ApiError>;
diff --git a/src-tauri/src/history.rs b/src-tauri/src/history.rs
new file mode 100644
index 00000000..c464adf9
--- /dev/null
+++ b/src-tauri/src/history.rs
@@ -0,0 +1,412 @@
+use std::ffi::{CStr, CString, c_char, c_int, c_void};
+use std::path::{Path, PathBuf};
+use std::ptr;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use crate::dto::{HistoryEntry, RunRequest};
+
+static NEXT_RUN_ID: AtomicU64 = AtomicU64::new(1);
+const SQLITE_OK: c_int = 0;
+const SQLITE_ROW: c_int = 100;
+const SQLITE_DONE: c_int = 101;
+const SQLITE_OPEN_READWRITE: c_int = 0x0000_0002;
+const SQLITE_OPEN_CREATE: c_int = 0x0000_0004;
+const SQLITE_OPEN_FULLMUTEX: c_int = 0x0001_0000;
+
+pub struct History {
+    path: PathBuf,
+}
+
+impl History {
+    pub fn open(path: &Path) -> anyhow::Result<Self> {
+        let history = Self {
+            path: path.to_owned(),
+        };
+        let database = Database::open(path)?;
+        database.exec(
+            "PRAGMA journal_mode=WAL;
+             PRAGMA foreign_keys=ON;
+             CREATE TABLE IF NOT EXISTS runs (
+                id TEXT PRIMARY KEY,
+                created_at_ms INTEGER NOT NULL,
+                kind TEXT NOT NULL,
+                target TEXT NOT NULL,
+                status TEXT NOT NULL,
+                request TEXT NOT NULL,
+                result TEXT NOT NULL DEFAULT '',
+                verification TEXT NOT NULL DEFAULT '',
+                error TEXT NOT NULL DEFAULT ''
+             );
+             CREATE INDEX IF NOT EXISTS runs_created_at ON runs(created_at_ms DESC);
+             UPDATE runs SET status = 'interrupted', error = 'Gate stopped before completion'
+               WHERE status = 'running';",
+        )?;
+        Ok(history)
+    }
+
+    pub fn begin(&self, request: &RunRequest) -> anyhow::Result<String> {
+        let now = now_ms();
+        let sequence = NEXT_RUN_ID.fetch_add(1, Ordering::Relaxed);
+        let id = format!("{now:x}-{sequence:x}");
+        let request_json = serde_json::to_string(request)?;
+        let database = Database::open(&self.path)?;
+        let mut statement = database.prepare(
+            "INSERT INTO runs(id, created_at_ms, kind, target, status, request)
+             VALUES (?1, ?2, ?3, ?4, 'running', ?5)",
+        )?;
+        statement.bind_text(1, &id)?;
+        statement.bind_i64(2, now)?;
+        statement.bind_text(3, &format!("{:?}", request.kind))?;
+        statement.bind_text(4, &request.target)?;
+        statement.bind_text(5, &request_json)?;
+        statement.done()?;
+        Ok(id)
+    }
+
+    pub fn fail(&self, id: &str, error: &str) -> anyhow::Result<()> {
+        let database = Database::open(&self.path)?;
+        let mut statement =
+            database.prepare("UPDATE runs SET status = 'failed', error = ?2 WHERE id = ?1")?;
+        statement.bind_text(1, id)?;
+        statement.bind_text(2, error)?;
+        statement.done()
+    }
+
+    pub fn append_result(&self, id: &str, value: &str) -> anyhow::Result<()> {
+        let database = Database::open(&self.path)?;
+        let mut statement =
+            database.prepare("UPDATE runs SET result = result || ?2 || char(10) WHERE id = ?1")?;
+        statement.bind_text(1, id)?;
+        statement.bind_text(2, value)?;
+        statement.done()
+    }
+
+    pub fn complete(&self, id: &str, verification: &str) -> anyhow::Result<()> {
+        let database = Database::open(&self.path)?;
+        let mut statement = database
+            .prepare("UPDATE runs SET status = 'complete', verification = ?2 WHERE id = ?1")?;
+        statement.bind_text(1, id)?;
+        statement.bind_text(2, verification)?;
+        statement.done()
+    }
+
+    pub fn list(&self, limit: u32) -> anyhow::Result<Vec<HistoryEntry>> {
+        let database = Database::open(&self.path)?;
+        let mut statement = database.prepare(
+            "SELECT id, created_at_ms, kind, target, status, request, result, verification, error
+             FROM runs ORDER BY created_at_ms DESC LIMIT ?1",
+        )?;
+        statement.bind_i64(1, i64::from(limit.min(500)))?;
+        let mut entries = Vec::new();
+        while statement.row()? {
+            entries.push(HistoryEntry {
+                id: statement.text(0),
+                created_at_ms: statement.i64(1),
+                kind: statement.text(2),
+                target: statement.text(3),
+                status: statement.text(4),
+                request: statement.text(5),
+                result: statement.text(6),
+                verification: statement.text(7),
+                error: statement.text(8),
+            });
+        }
+        Ok(entries)
+    }
+
+    pub fn delete(&self, id: &str) -> anyhow::Result<bool> {
+        let database = Database::open(&self.path)?;
+        let mut statement = database.prepare("DELETE FROM runs WHERE id = ?1")?;
+        statement.bind_text(1, id)?;
+        statement.done()?;
+        Ok(database.changes() > 0)
+    }
+
+    pub fn clear(&self) -> anyhow::Result<usize> {
+        let database = Database::open(&self.path)?;
+        database.exec("DELETE FROM runs")?;
+        Ok(database.changes().try_into().unwrap_or(usize::MAX))
+    }
+}
+
+struct Database(*mut Sqlite3);
+
+impl Database {
+    fn open(path: &Path) -> anyhow::Result<Self> {
+        let path = CString::new(path.to_string_lossy().as_bytes())?;
+        let mut handle = ptr::null_mut();
+        let result = unsafe {
+            sqlite3_open_v2(
+                path.as_ptr(),
+                &raw mut handle,
+                SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX,
+                ptr::null(),
+            )
+        };
+        if result != SQLITE_OK {
+            let message = sqlite_error(handle);
+            if !handle.is_null() {
+                unsafe { sqlite3_close(handle) };
+            }
+            anyhow::bail!("opening history database failed: {message}");
+        }
+        unsafe { sqlite3_busy_timeout(handle, 2_000) };
+        Ok(Self(handle))
+    }
+
+    fn exec(&self, sql: &str) -> anyhow::Result<()> {
+        let sql = CString::new(sql)?;
+        let mut error = ptr::null_mut();
+        let result =
+            unsafe { sqlite3_exec(self.0, sql.as_ptr(), None, ptr::null_mut(), &raw mut error) };
+        if result == SQLITE_OK {
+            return Ok(());
+        }
+        let message = if error.is_null() {
+            sqlite_error(self.0)
+        } else {
+            let message = unsafe { CStr::from_ptr(error) }
+                .to_string_lossy()
+                .into_owned();
+            unsafe { sqlite3_free(error.cast()) };
+            message
+        };
+        anyhow::bail!("history database command failed: {message}")
+    }
+
+    fn prepare<'a>(&'a self, sql: &str) -> anyhow::Result<Statement<'a>> {
+        let sql = CString::new(sql)?;
+        let mut statement = ptr::null_mut();
+        let result = unsafe {
+            sqlite3_prepare_v2(
+                self.0,
+                sql.as_ptr(),
+                -1,
+                &raw mut statement,
+                ptr::null_mut(),
+            )
+        };
+        if result != SQLITE_OK {
+            anyhow::bail!("preparing history query failed: {}", sqlite_error(self.0));
+        }
+        Ok(Statement {
+            database: self,
+            statement,
+        })
+    }
+
+    fn changes(&self) -> c_int {
+        unsafe { sqlite3_changes(self.0) }
+    }
+}
+
+impl Drop for Database {
+    fn drop(&mut self) {
+        unsafe { sqlite3_close(self.0) };
+    }
+}
+
+struct Statement<'a> {
+    database: &'a Database,
+    statement: *mut Sqlite3Statement,
+}
+
+impl Statement<'_> {
+    fn bind_text(&mut self, index: c_int, value: &str) -> anyhow::Result<()> {
+        let bytes = value.as_bytes();
+        let result = unsafe {
+            sqlite3_bind_text(
+                self.statement,
+                index,
+                bytes.as_ptr().cast(),
+                bytes.len().try_into()?,
+                sqlite_transient(),
+            )
+        };
+        self.check(result, "binding history text")
+    }
+
+    fn bind_i64(&mut self, index: c_int, value: i64) -> anyhow::Result<()> {
+        let result = unsafe { sqlite3_bind_int64(self.statement, index, value) };
+        self.check(result, "binding history integer")
+    }
+
+    fn done(&mut self) -> anyhow::Result<()> {
+        let result = unsafe { sqlite3_step(self.statement) };
+        if result == SQLITE_DONE {
+            Ok(())
+        } else {
+            anyhow::bail!("history mutation failed: {}", sqlite_error(self.database.0))
+        }
+    }
+
+    fn row(&mut self) -> anyhow::Result<bool> {
+        match unsafe { sqlite3_step(self.statement) } {
+            SQLITE_ROW => Ok(true),
+            SQLITE_DONE => Ok(false),
+            _ => anyhow::bail!("history query failed: {}", sqlite_error(self.database.0)),
+        }
+    }
+
+    fn text(&self, column: c_int) -> String {
+        let value = unsafe { sqlite3_column_text(self.statement, column) };
+        if value.is_null() {
+            String::new()
+        } else {
+            unsafe { CStr::from_ptr(value.cast()) }
+                .to_string_lossy()
+                .into_owned()
+        }
+    }
+
+    fn i64(&self, column: c_int) -> i64 {
+        unsafe { sqlite3_column_int64(self.statement, column) }
+    }
+
+    fn check(&self, result: c_int, action: &str) -> anyhow::Result<()> {
+        if result == SQLITE_OK {
+            Ok(())
+        } else {
+            anyhow::bail!("{action} failed: {}", sqlite_error(self.database.0))
+        }
+    }
+}
+
+impl Drop for Statement<'_> {
+    fn drop(&mut self) {
+        unsafe { sqlite3_finalize(self.statement) };
+    }
+}
+
+fn sqlite_transient() -> Option<unsafe extern "C" fn(*mut c_void)> {
+    // SQLite reserves the all-ones destructor value to mean "copy now".
+    unsafe { std::mem::transmute::<isize, _>(-1) }
+}
+
+fn sqlite_error(database: *mut Sqlite3) -> String {
+    if database.is_null() {
+        return "unknown SQLite error".into();
+    }
+    unsafe { CStr::from_ptr(sqlite3_errmsg(database)) }
+        .to_string_lossy()
+        .into_owned()
+}
+
+fn now_ms() -> i64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis()
+        .try_into()
+        .unwrap_or(i64::MAX)
+}
+
+#[repr(C)]
+struct Sqlite3 {
+    _private: [u8; 0],
+}
+
+#[repr(C)]
+struct Sqlite3Statement {
+    _private: [u8; 0],
+}
+
+#[link(name = "sqlite3")]
+unsafe extern "C" {
+    fn sqlite3_open_v2(
+        filename: *const c_char,
+        database: *mut *mut Sqlite3,
+        flags: c_int,
+        vfs: *const c_char,
+    ) -> c_int;
+    fn sqlite3_close(database: *mut Sqlite3) -> c_int;
+    fn sqlite3_busy_timeout(database: *mut Sqlite3, milliseconds: c_int) -> c_int;
+    fn sqlite3_errmsg(database: *mut Sqlite3) -> *const c_char;
+    fn sqlite3_exec(
+        database: *mut Sqlite3,
+        sql: *const c_char,
+        callback: Option<
+            unsafe extern "C" fn(*mut c_void, c_int, *mut *mut c_char, *mut *mut c_char) -> c_int,
+        >,
+        context: *mut c_void,
+        error: *mut *mut c_char,
+    ) -> c_int;
+    fn sqlite3_free(value: *mut c_void);
+    fn sqlite3_prepare_v2(
+        database: *mut Sqlite3,
+        sql: *const c_char,
+        sql_bytes: c_int,
+        statement: *mut *mut Sqlite3Statement,
+        tail: *mut *const c_char,
+    ) -> c_int;
+    fn sqlite3_finalize(statement: *mut Sqlite3Statement) -> c_int;
+    fn sqlite3_bind_text(
+        statement: *mut Sqlite3Statement,
+        index: c_int,
+        value: *const c_char,
+        bytes: c_int,
+        destructor: Option<unsafe extern "C" fn(*mut c_void)>,
+    ) -> c_int;
+    fn sqlite3_bind_int64(statement: *mut Sqlite3Statement, index: c_int, value: i64) -> c_int;
+    fn sqlite3_step(statement: *mut Sqlite3Statement) -> c_int;
+    fn sqlite3_column_text(statement: *mut Sqlite3Statement, column: c_int) -> *const u8;
+    fn sqlite3_column_int64(statement: *mut Sqlite3Statement, column: c_int) -> i64;
+    fn sqlite3_changes(database: *mut Sqlite3) -> c_int;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::dto::{AssuranceInput, RunKind};
+
+    fn request() -> RunRequest {
+        RunRequest {
+            kind: RunKind::Fetch,
+            target: "provider-node".into(),
+            node_addresses: Vec::new(),
+            input: r#"{"model":"test","input":"hello"}"#.into(),
+            trust_anchor: "genesis".into(),
+            service: "openai".into(),
+            method: "responses".into(),
+            execution_environment: "environment".into(),
+            assurance: AssuranceInput::ProducerSigned,
+            apple_app_id: String::new(),
+            apple_cd_hashes: Vec::new(),
+        }
+    }
+
+    #[test]
+    fn records_completion_and_supports_private_deletion() {
+        let directory = tempfile::tempdir().unwrap();
+        let history = History::open(&directory.path().join("history.sqlite3")).unwrap();
+        let id = history.begin(&request()).unwrap();
+        history.append_result(&id, "chunk").unwrap();
+        history.complete(&id, "verified").unwrap();
+
+        let entries = history.list(10).unwrap();
+        assert_eq!(entries.len(), 1);
+        assert_eq!(entries[0].status, "complete");
+        assert_eq!(entries[0].result, "chunk\n");
+        assert_eq!(entries[0].verification, "verified");
+        assert!(entries[0].request.contains("trustAnchor"));
+        assert!(history.delete(&id).unwrap());
+        assert!(history.list(10).unwrap().is_empty());
+    }
+
+    #[test]
+    fn marks_incomplete_runs_interrupted_on_reopen() {
+        let directory = tempfile::tempdir().unwrap();
+        let path = directory.path().join("history.sqlite3");
+        let history = History::open(&path).unwrap();
+        let id = history.begin(&request()).unwrap();
+        drop(history);
+
+        let reopened = History::open(&path).unwrap();
+        let entry = reopened.list(1).unwrap().pop().unwrap();
+        assert_eq!(entry.id, id);
+        assert_eq!(entry.status, "interrupted");
+        assert_eq!(entry.error, "Gate stopped before completion");
+        assert_eq!(reopened.clear().unwrap(), 1);
+    }
+}
diff --git a/src-tauri/src/host_control.rs b/src-tauri/src/host_control.rs
new file mode 100644
index 00000000..08cfcb9d
--- /dev/null
+++ b/src-tauri/src/host_control.rs
@@ -0,0 +1,194 @@
+use std::io;
+use std::os::fd::AsRawFd;
+use std::os::unix::fs::{FileTypeExt, PermissionsExt};
+use std::path::Path;
+use std::sync::Arc;
+
+use hellas_rpc::pb::host::{
+    AttestationState, GatewayAccess, GetGatewayAccessRequest, GetHostStatusRequest, HostStatus,
+    IdentityStatus, RuntimeState, ServiceStatus, SetGatewayStateRequest, SetProviderStateRequest,
+};
+use hellas_rpc::services::host_control::{HostControlHandler, HostControlServer};
+use hellas_wire::mux::{MuxTransport, Role};
+use hellas_wire::{Dispatcher, StreamTransport, TransportContext, WireCode, WireStatus};
+use tokio::net::{UnixListener, UnixStream};
+
+use crate::dto;
+use crate::state::AppState;
+
+pub async fn serve(state: Arc<AppState>) -> anyhow::Result<()> {
+    prepare_socket(state.socket_path())?;
+    let listener = UnixListener::bind(state.socket_path())?;
+    std::fs::set_permissions(state.socket_path(), std::fs::Permissions::from_mode(0o600))?;
+
+    loop {
+        let (stream, _) = listener.accept().await?;
+        if peer_uid(&stream)? != unsafe { libc::geteuid() } {
+            tracing::warn!("rejected local-control connection from another uid");
+            continue;
+        }
+        let state = state.clone();
+        tokio::spawn(async move {
+            if let Err(error) = serve_connection(stream, state).await {
+                tracing::warn!(%error, "local-control connection ended");
+            }
+        });
+    }
+}
+
+async fn serve_connection(stream: UnixStream, state: Arc<AppState>) -> anyhow::Result<()> {
+    let transport =
+        hellas_sdk::local::transport(stream, Role::Server, TransportContext::default())?;
+    let server = HostControlServer(Handler(state));
+    while let Some(inbound) = transport.accept().await? {
+        Dispatcher::<MuxTransport>::dispatch(&server, inbound).await?;
+    }
+    Ok(())
+}
+
+#[derive(Clone)]
+struct Handler(Arc<AppState>);
+
+#[allow(refining_impl_trait)]
+impl HostControlHandler for Handler {
+    async fn get_host_status(
+        &self,
+        _request: GetHostStatusRequest,
+    ) -> Result<HostStatus, WireStatus> {
+        Ok(to_proto(self.0.status().await))
+    }
+
+    async fn set_provider_state(
+        &self,
+        request: SetProviderStateRequest,
+    ) -> Result<HostStatus, WireStatus> {
+        self.0
+            .set_provider_enabled(request.enabled, None)
+            .await
+            .map(to_proto)
+            .map_err(|error| WireStatus::internal(error.to_string()))
+    }
+
+    async fn set_gateway_state(
+        &self,
+        request: SetGatewayStateRequest,
+    ) -> Result<HostStatus, WireStatus> {
+        self.0
+            .set_gateway_enabled(request.enabled, None)
+            .await
+            .map(to_proto)
+            .map_err(|error| WireStatus::internal(error.to_string()))
+    }
+
+    async fn get_gateway_access(
+        &self,
+        _request: GetGatewayAccessRequest,
+    ) -> Result<GatewayAccess, WireStatus> {
+        self.0
+            .gateway_access()
+            .await
+            .map(|access| GatewayAccess {
+                address: access.address,
+                bearer: access.bearer,
+            })
+            .ok_or_else(|| WireStatus::new(WireCode::FailedPrecondition, "gateway is not running"))
+    }
+}
+
+fn to_proto(status: dto::AppStatus) -> HostStatus {
+    HostStatus {
+        version: status.version,
+        identity: Some(IdentityStatus {
+            producer_id: status.identity.producer_id,
+            caller_public_key: status.identity.caller_public_key,
+            node_id: status.identity.node_id,
+            attestation: match status.identity.attestation.as_str() {
+                "apple-app-attest" => AttestationState::AppleAppAttest as i32,
+                "software" => AttestationState::Software as i32,
+                "available" => AttestationState::Enrolling as i32,
+                _ => AttestationState::Unavailable as i32,
+            },
+            detail: status.identity.detail,
+        }),
+        provider: Some(service_to_proto(status.provider)),
+        gateway: Some(service_to_proto(status.gateway)),
+        endpoint: status.endpoint,
+    }
+}
+
+fn service_to_proto(status: dto::ServiceStatus) -> ServiceStatus {
+    ServiceStatus {
+        state: match status.state {
+            dto::ServiceState::Stopped => RuntimeState::Stopped as i32,
+            dto::ServiceState::Starting => RuntimeState::Starting as i32,
+            dto::ServiceState::Running => RuntimeState::Running as i32,
+            dto::ServiceState::Stopping => RuntimeState::Stopping as i32,
+            dto::ServiceState::Failed => RuntimeState::Failed as i32,
+        },
+        detail: status.detail,
+    }
+}
+
+fn prepare_socket(path: &Path) -> io::Result<()> {
+    match std::fs::symlink_metadata(path) {
+        Ok(metadata) if metadata.file_type().is_socket() => {
+            match std::os::unix::net::UnixStream::connect(path) {
+                Ok(_) => Err(io::Error::new(
+                    io::ErrorKind::AddrInUse,
+                    "another Gate process owns the local-control socket",
+                )),
+                Err(error)
+                    if matches!(
+                        error.kind(),
+                        io::ErrorKind::ConnectionRefused | io::ErrorKind::NotFound
+                    ) =>
+                {
+                    std::fs::remove_file(path)
+                }
+                Err(error) => Err(error),
+            }
+        }
+        Ok(_) => Err(io::Error::new(
+            io::ErrorKind::AlreadyExists,
+            "refusing to replace a non-socket local-control path",
+        )),
+        Err(error) if error.kind() == io::ErrorKind::NotFound => Ok(()),
+        Err(error) => Err(error),
+    }
+}
+
+#[cfg(target_os = "linux")]
+fn peer_uid(stream: &UnixStream) -> io::Result<libc::uid_t> {
+    let mut credentials = libc::ucred {
+        pid: 0,
+        uid: 0,
+        gid: 0,
+    };
+    let mut length = std::mem::size_of::<libc::ucred>() as libc::socklen_t;
+    let result = unsafe {
+        libc::getsockopt(
+            stream.as_raw_fd(),
+            libc::SOL_SOCKET,
+            libc::SO_PEERCRED,
+            (&raw mut credentials).cast(),
+            &raw mut length,
+        )
+    };
+    if result == 0 {
+        Ok(credentials.uid)
+    } else {
+        Err(io::Error::last_os_error())
+    }
+}
+
+#[cfg(any(target_os = "macos", target_os = "freebsd", target_os = "openbsd"))]
+fn peer_uid(stream: &UnixStream) -> io::Result<libc::uid_t> {
+    let mut uid = 0;
+    let mut gid = 0;
+    let result = unsafe { libc::getpeereid(stream.as_raw_fd(), &raw mut uid, &raw mut gid) };
+    if result == 0 {
+        Ok(uid)
+    } else {
+        Err(io::Error::last_os_error())
+    }
+}
diff --git a/src-tauri/src/identity.rs b/src-tauri/src/identity.rs
new file mode 100644
index 00000000..fd8feac8
--- /dev/null
+++ b/src-tauri/src/identity.rs
@@ -0,0 +1,104 @@
+use std::fs;
+use std::io::{ErrorKind, Write};
+use std::path::Path;
+
+use anyhow::Context;
+use hellas_sdk::ClientIdentity;
+
+const TAG: &[u8] = b"hellas.gate.client.v1\0";
+const SECRET_BYTES: usize = 64;
+
+/// Load the stable transport/caller identity owned by this installation, or
+/// create it exactly once. The format is intentionally tiny and private to
+/// Gate; provider enrollment is a separate, attested record.
+pub fn load_or_create(path: &Path) -> anyhow::Result<ClientIdentity> {
+    match fs::read(path) {
+        Ok(bytes) => decode(&bytes),
+        Err(error) if error.kind() == ErrorKind::NotFound => create(path),
+        Err(error) => Err(error).with_context(|| format!("reading {} failed", path.display())),
+    }
+}
+
+fn create(path: &Path) -> anyhow::Result<ClientIdentity> {
+    let identity = ClientIdentity::generate();
+    let mut bytes = Vec::with_capacity(TAG.len() + SECRET_BYTES);
+    bytes.extend_from_slice(TAG);
+    bytes.extend_from_slice(&identity.transport_secret_bytes());
+    bytes.extend_from_slice(&identity.caller_secret_bytes());
+
+    let directory = path.parent().context("identity path has no parent")?;
+    let mut temporary = tempfile::NamedTempFile::new_in(directory)?;
+    #[cfg(unix)]
+    temporary.as_file().set_permissions({
+        use std::os::unix::fs::PermissionsExt;
+        fs::Permissions::from_mode(0o600)
+    })?;
+    temporary.write_all(&bytes)?;
+    temporary.flush()?;
+    temporary.as_file().sync_all()?;
+    match temporary.persist_noclobber(path) {
+        Ok(_) => {
+            #[cfg(unix)]
+            fs::File::open(directory)?.sync_all()?;
+            Ok(identity)
+        }
+        Err(_) if path.exists() => decode(&fs::read(path)?),
+        Err(error) => Err(error.error).context("persisting Gate identity failed"),
+    }
+}
+
+fn decode(bytes: &[u8]) -> anyhow::Result<ClientIdentity> {
+    anyhow::ensure!(
+        bytes.len() == TAG.len() + SECRET_BYTES && bytes.starts_with(TAG),
+        "unsupported Gate identity format"
+    );
+    let transport = bytes[TAG.len()..TAG.len() + 32].try_into().unwrap();
+    let caller = bytes[TAG.len() + 32..].try_into().unwrap();
+    ClientIdentity::from_secret_bytes(transport, caller).map_err(Into::into)
+}
+
+pub fn producer_id(identity: &ClientIdentity) -> String {
+    encode_hex(identity.caller_key().producer_id().as_bytes())
+}
+
+pub fn public_key(identity: &ClientIdentity) -> String {
+    encode_hex(identity.caller_key().public_key().bytes())
+}
+
+fn encode_hex(bytes: &[u8]) -> String {
+    const DIGITS: &[u8; 16] = b"0123456789abcdef";
+    let mut output = String::with_capacity(bytes.len() * 2);
+    for byte in bytes {
+        output.push(DIGITS[(byte >> 4) as usize] as char);
+        output.push(DIGITS[(byte & 0x0f) as usize] as char);
+    }
+    output
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn identity_is_stable_and_private() {
+        let directory = tempfile::tempdir().unwrap();
+        let path = directory.path().join("identity");
+        let first = load_or_create(&path).unwrap();
+        let second = load_or_create(&path).unwrap();
+        assert_eq!(first.node_id(), second.node_id());
+        assert_eq!(producer_id(&first), producer_id(&second));
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::PermissionsExt;
+            assert_eq!(
+                fs::metadata(path).unwrap().permissions().mode() & 0o777,
+                0o600
+            );
+        }
+    }
+
+    #[test]
+    fn rejects_unknown_format() {
+        assert!(decode(b"not an identity").is_err());
+    }
+}
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
new file mode 100644
index 00000000..39c8edb6
--- /dev/null
+++ b/src-tauri/src/lib.rs
@@ -0,0 +1,11 @@
+pub mod apple;
+#[cfg(feature = "desktop")]
+pub mod commands;
+pub mod dto;
+pub mod error;
+pub mod history;
+#[cfg(unix)]
+pub mod host_control;
+pub mod identity;
+pub mod provider_identity;
+pub mod state;
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
new file mode 100644
index 00000000..f6b7bcdc
--- /dev/null
+++ b/src-tauri/src/main.rs
@@ -0,0 +1,90 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+use std::sync::Arc;
+
+use hellas_gate::state::AppState;
+use hellas_gate::{commands, host_control};
+use tauri::menu::{Menu, MenuItem};
+use tauri::tray::TrayIconBuilder;
+use tauri::{Manager, WindowEvent};
+
+fn main() {
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| "hellas_gate=info".into()),
+        )
+        .init();
+
+    tauri::Builder::default()
+        .setup(|app| {
+            let data_dir = app.path().app_data_dir()?;
+            create_private_directory(&data_dir)?;
+            let state = Arc::new(AppState::open(&data_dir)?);
+            app.manage(state.clone());
+
+            #[cfg(unix)]
+            tauri::async_runtime::spawn(async move {
+                if let Err(error) = host_control::serve(state).await {
+                    tracing::error!(%error, "local-control listener stopped");
+                }
+            });
+
+            install_tray(app)?;
+            Ok(())
+        })
+        .invoke_handler(tauri::generate_handler![
+            commands::get_status,
+            commands::set_provider_enabled,
+            commands::set_gateway_enabled,
+            commands::get_gateway_access,
+            commands::run_request,
+            commands::list_history,
+            commands::delete_history,
+            commands::clear_history,
+        ])
+        .on_window_event(|window, event| {
+            if let WindowEvent::CloseRequested { api, .. } = event {
+                api.prevent_close();
+                if let Err(error) = window.hide() {
+                    tracing::warn!(%error, "failed to hide Gate window");
+                }
+            }
+        })
+        .run(tauri::generate_context!())
+        .expect("failed to run Hellas Gate");
+}
+
+fn install_tray(app: &mut tauri::App) -> tauri::Result<()> {
+    let open = MenuItem::with_id(app, "open", "Open Gate", true, None::<&str>)?;
+    let quit = MenuItem::with_id(app, "quit", "Quit", true, None::<&str>)?;
+    let menu = Menu::with_items(app, &[&open, &quit])?;
+    let mut tray = TrayIconBuilder::new()
+        .menu(&menu)
+        .tooltip("Hellas Gate")
+        .on_menu_event(|app, event| match event.id().as_ref() {
+            "open" => {
+                if let Some(window) = app.get_webview_window("main") {
+                    let _ = window.show();
+                    let _ = window.set_focus();
+                }
+            }
+            "quit" => app.exit(0),
+            _ => {}
+        });
+    if let Some(icon) = app.default_window_icon() {
+        tray = tray.icon(icon.clone());
+    }
+    tray.build(app)?;
+    Ok(())
+}
+
+fn create_private_directory(path: &std::path::Path) -> std::io::Result<()> {
+    std::fs::create_dir_all(path)?;
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o700))?;
+    }
+    Ok(())
+}
diff --git a/src-tauri/src/provider_identity.rs b/src-tauri/src/provider_identity.rs
new file mode 100644
index 00000000..0f598489
--- /dev/null
+++ b/src-tauri/src/provider_identity.rs
@@ -0,0 +1,240 @@
+mod platform {
+    use std::fs;
+    use std::io::{ErrorKind, Write};
+    use std::path::Path;
+    use std::sync::Arc;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    use anyhow::{Context, bail};
+    use hellas_attestation::{
+        AnchorTime, AppleCredential, ApplePolicy, RegisteredAppleCredential, RootProver,
+        apple_app_attest_root_ca, apple_client_data_hash, apple_credential_identity,
+        register_apple, verify_apple_assertion,
+    };
+    use hellas_rpc::{
+        AppleAppAttestEnrollment, DagCborDecoder, DagCborEncoder, Digest, PlatformCredential,
+        PlatformEnrollment, ProviderEnrollmentBundle, ProviderGenesisStatement, PublicKey,
+        RootKind, RootProof, SignedProviderGenesis,
+    };
+    use hellas_sdk::ClientIdentity;
+
+    use crate::apple::AppleAppAttestRoot;
+
+    const TAG: &str = "hellas.gate.provider-identity.v1";
+    const VERSION: u64 = 1;
+
+    pub struct ProviderIdentity {
+        root: Arc<AppleAppAttestRoot>,
+        enrollment: ProviderEnrollmentBundle,
+    }
+
+    impl ProviderIdentity {
+        pub fn enrollment(&self) -> &ProviderEnrollmentBundle {
+            &self.enrollment
+        }
+
+        pub fn root(&self) -> Arc<AppleAppAttestRoot> {
+            self.root.clone()
+        }
+    }
+
+    pub async fn load_or_create(
+        path: &Path,
+        client: &ClientIdentity,
+    ) -> anyhow::Result<ProviderIdentity> {
+        match fs::read(path) {
+            Ok(bytes) => materialize(&bytes, client),
+            Err(error) if error.kind() == ErrorKind::NotFound => create(path, client).await,
+            Err(error) => Err(error).with_context(|| format!("reading {} failed", path.display())),
+        }
+    }
+
+    async fn create(path: &Path, client: &ClientIdentity) -> anyhow::Result<ProviderIdentity> {
+        let installation_nonce = installation_nonce(client);
+        let enrollment_statement = enrollment_statement(installation_nonce);
+        let (root, credential) =
+            tokio::task::spawn_blocking(move || AppleAppAttestRoot::create(&enrollment_statement))
+                .await
+                .context("Apple App Attest enrollment task failed")??;
+        let validation_time = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .context("system clock is before the Unix epoch")?
+            .as_secs();
+        let credential_identity = apple_credential_identity(&credential.attestation)?;
+        let registered = register_apple(
+            &credential,
+            credential_identity.rp_id_hash,
+            apple_app_attest_root_ca(),
+            AnchorTime(validation_time),
+        )?;
+        let statement = provider_statement(client, installation_nonce, &credential, &registered);
+        let genesis = SignedProviderGenesis {
+            root_proof: root.prove_statement(&statement.canonical_bytes()).await?,
+            statement,
+        };
+        let enrollment = ProviderEnrollmentBundle {
+            genesis,
+            platform: PlatformEnrollment::AppleAppAttest(AppleAppAttestEnrollment {
+                attestation_object: credential.attestation,
+                client_data_hash: credential.client_data_hash,
+                validation_time,
+            }),
+        };
+        validate(&enrollment, client)?;
+        let stored = encode(root.key(), &enrollment);
+        persist(path, &stored)?;
+        Ok(ProviderIdentity {
+            root: Arc::new(root),
+            enrollment,
+        })
+    }
+
+    fn materialize(bytes: &[u8], client: &ClientIdentity) -> anyhow::Result<ProviderIdentity> {
+        let (key, enrollment) = decode(bytes)?;
+        validate(&enrollment, client)?;
+        let PlatformEnrollment::AppleAppAttest(platform) = &enrollment.platform else {
+            bail!("Gate provider identity does not contain Apple enrollment");
+        };
+        let credential = AppleCredential {
+            attestation: platform.attestation_object.clone(),
+            client_data_hash: platform.client_data_hash,
+        };
+        Ok(ProviderIdentity {
+            root: Arc::new(AppleAppAttestRoot::load(key, credential.content_id())),
+            enrollment,
+        })
+    }
+
+    fn validate(
+        enrollment: &ProviderEnrollmentBundle,
+        client: &ClientIdentity,
+    ) -> anyhow::Result<()> {
+        let PlatformEnrollment::AppleAppAttest(platform) = &enrollment.platform else {
+            bail!("Gate provider identity requires Apple App Attest enrollment");
+        };
+        let credential = AppleCredential {
+            attestation: platform.attestation_object.clone(),
+            client_data_hash: platform.client_data_hash,
+        };
+        let credential_identity = apple_credential_identity(&credential.attestation)?;
+        let registered = register_apple(
+            &credential,
+            credential_identity.rp_id_hash,
+            apple_app_attest_root_ca(),
+            AnchorTime(platform.validation_time),
+        )?;
+        let statement = &enrollment.genesis.statement;
+        anyhow::ensure!(
+            statement.root_kind == RootKind::SecureEnclave
+                && statement.root_public_key == PublicKey::P256(registered.public_key)
+                && statement.producer_public_key == client.caller_key().public_key()
+                && statement.transport_public_key
+                    == PublicKey::Ed25519(*client.node_id().as_bytes())
+                && statement.platform_credential
+                    == PlatformCredential::Registered(credential.content_id()),
+            "persisted Apple provider identity does not match this Gate installation"
+        );
+        let RootProof::AppleAppAttest(assertion) = &enrollment.genesis.root_proof else {
+            bail!("Apple provider identity requires an App Attest root proof");
+        };
+        verify_apple_assertion(
+            assertion,
+            &apple_client_data_hash(&statement.canonical_bytes()),
+            &RegisteredAppleCredential {
+                id: credential.content_id(),
+                public_key: registered.public_key,
+            },
+            &ApplePolicy {
+                expected_rp_id_hash: credential_identity.rp_id_hash,
+                allowed_cd_hashes: vec![credential_identity.cd_hash],
+            },
+        )?;
+        Ok(())
+    }
+
+    fn provider_statement(
+        client: &ClientIdentity,
+        installation_nonce: [u8; 32],
+        credential: &AppleCredential,
+        registered: &RegisteredAppleCredential,
+    ) -> ProviderGenesisStatement {
+        ProviderGenesisStatement {
+            root_kind: RootKind::SecureEnclave,
+            root_public_key: PublicKey::P256(registered.public_key),
+            producer_public_key: client.caller_key().public_key(),
+            transport_public_key: PublicKey::Ed25519(*client.node_id().as_bytes()),
+            platform_credential: PlatformCredential::Registered(credential.content_id()),
+            installation_nonce,
+        }
+    }
+
+    fn installation_nonce(client: &ClientIdentity) -> [u8; 32] {
+        let mut encoder = DagCborEncoder::new();
+        encoder.array(3);
+        encoder.str("hellas.gate.installation-nonce.v1");
+        encoder.bytes(&client.transport_secret_bytes());
+        encoder.bytes(&client.caller_secret_bytes());
+        *Digest::hash(&encoder.into_bytes()).as_bytes()
+    }
+
+    fn enrollment_statement(installation_nonce: [u8; 32]) -> Vec<u8> {
+        let mut encoder = DagCborEncoder::new();
+        encoder.array(2);
+        encoder.str("hellas.apple.app-attest.enrollment.v1");
+        encoder.bytes(&installation_nonce);
+        encoder.into_bytes()
+    }
+
+    fn encode(key: &str, enrollment: &ProviderEnrollmentBundle) -> Vec<u8> {
+        let mut encoder = DagCborEncoder::new();
+        encoder.array(4);
+        encoder.str(TAG);
+        encoder.u64(VERSION);
+        encoder.str(key);
+        encoder.bytes(&enrollment.canonical_bytes());
+        encoder.into_bytes()
+    }
+
+    fn decode(bytes: &[u8]) -> anyhow::Result<(String, ProviderEnrollmentBundle)> {
+        let mut decoder = DagCborDecoder::new(bytes);
+        decoder.array(4, "Gate provider identity")?;
+        decoder.tag(TAG)?;
+        anyhow::ensure!(
+            decoder.u64("Gate provider identity version")? == VERSION,
+            "unsupported Gate provider identity version"
+        );
+        let key = decoder.text("Apple App Attest key")?.to_owned();
+        let enrollment =
+            ProviderEnrollmentBundle::from_canonical_bytes(decoder.bytes("provider enrollment")?)?;
+        decoder.finish()?;
+        anyhow::ensure!(
+            encode(&key, &enrollment) == bytes,
+            "Gate provider identity is not canonical"
+        );
+        Ok((key, enrollment))
+    }
+
+    fn persist(path: &Path, bytes: &[u8]) -> anyhow::Result<()> {
+        let directory = path
+            .parent()
+            .context("provider identity path has no parent")?;
+        let mut temporary = tempfile::NamedTempFile::new_in(directory)?;
+        use std::os::unix::fs::PermissionsExt;
+        temporary
+            .as_file()
+            .set_permissions(fs::Permissions::from_mode(0o600))?;
+        temporary.write_all(bytes)?;
+        temporary.flush()?;
+        temporary.as_file().sync_all()?;
+        match temporary.persist_noclobber(path) {
+            Ok(_) => {
+                fs::File::open(directory)?.sync_all()?;
+                Ok(())
+            }
+            Err(_) if path.exists() => Ok(()),
+            Err(error) => Err(error.error).context("persisting provider identity failed"),
+        }
+    }
+}
+
+pub use platform::{ProviderIdentity, load_or_create};
diff --git a/src-tauri/src/state.rs b/src-tauri/src/state.rs
new file mode 100644
index 00000000..39831a86
--- /dev/null
+++ b/src-tauri/src/state.rs
@@ -0,0 +1,453 @@
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use anyhow::{Context, bail};
+use tokio::sync::{Mutex, OnceCell, RwLock};
+
+use crate::apple;
+use crate::dto::{
+    AppStatus, AssuranceInput, GatewayAccess, IdentityStatus, ProviderConfig, RunKind, RunRequest,
+    ServiceState, ServiceStatus,
+};
+use crate::history::History;
+use crate::identity;
+
+struct RuntimeStatus {
+    provider: ServiceStatus,
+    provider_handle: Option<hellas_sdk::ProviderHandle>,
+    gateway: ServiceStatus,
+    gateway_access: Option<GatewayAccess>,
+    gateway_handle: Option<hellas_sdk::gateway::GatewayHandle>,
+    gateway_config: Option<RunRequest>,
+}
+
+pub struct AppState {
+    pub history: History,
+    socket_path: PathBuf,
+    counter_directory: PathBuf,
+    identity: hellas_sdk::ClientIdentity,
+    #[cfg(target_os = "macos")]
+    provider_identity_path: PathBuf,
+    #[cfg(target_os = "macos")]
+    provider_state_directory: PathBuf,
+    provider_identity: OnceCell<Arc<crate::provider_identity::ProviderIdentity>>,
+    client: OnceCell<hellas_sdk::HellasClient>,
+    lifecycle: Mutex<()>,
+    runtime: RwLock<RuntimeStatus>,
+}
+
+impl AppState {
+    pub fn open(data_dir: &Path) -> anyhow::Result<Self> {
+        let identity = identity::load_or_create(&data_dir.join("identity"))?;
+        Ok(Self {
+            history: History::open(&data_dir.join("history.sqlite3"))?,
+            socket_path: data_dir.join("gate.sock"),
+            counter_directory: data_dir.join("apple-assertion-counters"),
+            identity,
+            #[cfg(target_os = "macos")]
+            provider_identity_path: data_dir.join("provider-identity"),
+            #[cfg(target_os = "macos")]
+            provider_state_directory: data_dir.join("provider"),
+            provider_identity: OnceCell::new(),
+            client: OnceCell::new(),
+            lifecycle: Mutex::new(()),
+            runtime: RwLock::new(RuntimeStatus {
+                provider: stopped("Not configured"),
+                provider_handle: None,
+                gateway: stopped("Not configured"),
+                gateway_access: None,
+                gateway_handle: None,
+                gateway_config: None,
+            }),
+        })
+    }
+
+    pub fn socket_path(&self) -> &Path {
+        &self.socket_path
+    }
+
+    pub async fn status(&self) -> AppStatus {
+        let runtime = self.runtime.read().await;
+        AppStatus {
+            version: env!("CARGO_PKG_VERSION").into(),
+            identity: IdentityStatus {
+                producer_id: identity::producer_id(&self.identity),
+                caller_public_key: identity::public_key(&self.identity),
+                node_id: self.identity.node_id().to_string(),
+                attestation: if self.provider_identity.get().is_some() {
+                    "apple-app-attest".into()
+                } else {
+                    apple::availability().label.into()
+                },
+                detail: if self.provider_identity.get().is_some() {
+                    "Apple App Attest provider enrollment is active".into()
+                } else {
+                    apple::availability().detail.into()
+                },
+            },
+            provider: runtime.provider.clone(),
+            gateway: runtime.gateway.clone(),
+            endpoint: runtime
+                .provider_handle
+                .as_ref()
+                .map(|handle| handle.node_id().to_string())
+                .unwrap_or_default(),
+            socket_path: self.socket_path.display().to_string(),
+        }
+    }
+
+    pub async fn set_provider_enabled(
+        &self,
+        enabled: bool,
+        config: Option<ProviderConfig>,
+    ) -> anyhow::Result<AppStatus> {
+        let _lifecycle = self.lifecycle.lock().await;
+        if !enabled {
+            let handle = {
+                let mut runtime = self.runtime.write().await;
+                runtime.provider = ServiceStatus {
+                    state: ServiceState::Stopping,
+                    detail: "Stopping Hellas Fetch provider".into(),
+                };
+                runtime.provider_handle.take()
+            };
+            if let Some(handle) = handle {
+                handle.shutdown().await;
+            }
+            self.runtime.write().await.provider = stopped("Stopped by user");
+            return Ok(self.status().await);
+        }
+
+        let config = {
+            let runtime = self.runtime.read().await;
+            if runtime.provider_handle.is_some() {
+                drop(runtime);
+                return Ok(self.status().await);
+            }
+            config.context("configure an upstream and allowed caller before serving")?
+        };
+        self.runtime.write().await.provider = ServiceStatus {
+            state: ServiceState::Starting,
+            detail: "Creating or loading the attested provider identity".into(),
+        };
+        match self.start_provider(config).await {
+            Ok(handle) => {
+                let node_id = handle.node_id().to_string();
+                let sockets = handle
+                    .bound_sockets()
+                    .into_iter()
+                    .map(|address| address.to_string())
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                let mut runtime = self.runtime.write().await;
+                runtime.provider = ServiceStatus {
+                    state: ServiceState::Running,
+                    detail: format!("Attested Fetch provider {node_id} on {sockets}"),
+                };
+                runtime.provider_handle = Some(handle);
+                drop(runtime);
+                Ok(self.status().await)
+            }
+            Err(error) => {
+                self.runtime.write().await.provider = ServiceStatus {
+                    state: ServiceState::Failed,
+                    detail: error.to_string(),
+                };
+                Err(error)
+            }
+        }
+    }
+
+    #[cfg(target_os = "macos")]
+    async fn start_provider(
+        &self,
+        config: ProviderConfig,
+    ) -> anyhow::Result<hellas_sdk::ProviderHandle> {
+        anyhow::ensure!(
+            !config.service.trim().is_empty() && !config.method.trim().is_empty(),
+            "Fetch service and method must be non-empty"
+        );
+        anyhow::ensure!(
+            !config.openai_api_key.trim().is_empty(),
+            "OpenAI API key must be non-empty"
+        );
+        let callers = config
+            .allowed_callers
+            .iter()
+            .map(|key| decode_public_key(key))
+            .collect::<anyhow::Result<Vec<_>>>()?;
+        anyhow::ensure!(
+            !callers.is_empty(),
+            "at least one allowed caller is required"
+        );
+        let provider_identity = self
+            .provider_identity
+            .get_or_try_init(|| async {
+                crate::provider_identity::load_or_create(
+                    &self.provider_identity_path,
+                    &self.identity,
+                )
+                .await
+                .map(Arc::new)
+            })
+            .await?;
+        hellas_sdk::start_openai_provider(hellas_sdk::OpenAiProviderOptions {
+            port: config.port,
+            identity: self.identity.clone(),
+            enrollment: provider_identity.enrollment().clone(),
+            root: provider_identity.root(),
+            state_directory: self.provider_state_directory.clone(),
+            service: config.service,
+            method: config.method,
+            bearer_token: config.openai_api_key,
+            allowed_callers: callers,
+            fetch_max_in_flight: hellas_rpc::DEFAULT_FETCH_MAX_IN_FLIGHT,
+            fetch_queue_capacity: hellas_rpc::DEFAULT_FETCH_QUEUE_CAPACITY,
+            retained_transcript_capacity: hellas_rpc::DEFAULT_FETCH_RETAINED_TRANSCRIPT_CAPACITY,
+            fetch_replay_max_in_flight: hellas_rpc::DEFAULT_FETCH_REPLAY_MAX_IN_FLIGHT,
+        })
+        .await
+    }
+
+    #[cfg(not(target_os = "macos"))]
+    async fn start_provider(
+        &self,
+        _config: ProviderConfig,
+    ) -> anyhow::Result<hellas_sdk::ProviderHandle> {
+        bail!("the attested provider requires a provisioned macOS Gate build")
+    }
+
+    pub async fn set_gateway_enabled(
+        &self,
+        enabled: bool,
+        config: Option<RunRequest>,
+    ) -> anyhow::Result<AppStatus> {
+        let _lifecycle = self.lifecycle.lock().await;
+        if !enabled {
+            let handle = {
+                let mut runtime = self.runtime.write().await;
+                runtime.gateway = ServiceStatus {
+                    state: ServiceState::Stopping,
+                    detail: "Stopping loopback listener".into(),
+                };
+                runtime.gateway_access = None;
+                runtime.gateway_handle.take()
+            };
+            if let Some(handle) = handle {
+                handle.shutdown().await?;
+            }
+            self.runtime.write().await.gateway = stopped("Stopped by user");
+            return Ok(self.status().await);
+        }
+
+        let config = {
+            let mut runtime = self.runtime.write().await;
+            if runtime.gateway_handle.is_some() {
+                drop(runtime);
+                return Ok(self.status().await);
+            }
+            if let Some(config) = config {
+                runtime.gateway_config = Some(config);
+            }
+            runtime
+                .gateway_config
+                .clone()
+                .context("configure a trusted Fetch provider before starting the gateway")?
+        };
+        let options = self.fetch_gateway_options(&config)?;
+        self.runtime.write().await.gateway = ServiceStatus {
+            state: ServiceState::Starting,
+            detail: "Binding a private loopback endpoint".into(),
+        };
+        match hellas_sdk::gateway::start_fetch(options).await {
+            Ok(handle) => {
+                let access = GatewayAccess {
+                    address: format!("http://{}", handle.address()),
+                    bearer: handle.bearer().to_owned(),
+                };
+                let mut runtime = self.runtime.write().await;
+                runtime.gateway = ServiceStatus {
+                    state: ServiceState::Running,
+                    detail: format!("Responses endpoint at {}/v1/responses", access.address),
+                };
+                runtime.gateway_access = Some(access);
+                runtime.gateway_handle = Some(handle);
+                drop(runtime);
+                Ok(self.status().await)
+            }
+            Err(error) => {
+                self.runtime.write().await.gateway = ServiceStatus {
+                    state: ServiceState::Failed,
+                    detail: error.to_string(),
+                };
+                Err(error)
+            }
+        }
+    }
+
+    pub async fn gateway_access(&self) -> Option<GatewayAccess> {
+        self.runtime.read().await.gateway_access.clone()
+    }
+
+    fn fetch_gateway_options(
+        &self,
+        request: &RunRequest,
+    ) -> anyhow::Result<hellas_sdk::gateway::FetchGatewayOptions> {
+        if !matches!(request.kind, RunKind::Fetch) {
+            bail!("the minimal loopback gateway supports sealed Fetch Responses")
+        }
+        let (node_id, node_addrs, execution_environment, assurance, provider_trust) =
+            self.remote_fetch_parameters(request)?;
+        Ok(hellas_sdk::gateway::FetchGatewayOptions {
+            host: "127.0.0.1".into(),
+            port: Some(0),
+            node_id: Some(node_id),
+            node_addrs,
+            retries: 1,
+            service: request.service.clone(),
+            method: request.method.clone(),
+            execution_environment,
+            request_overrides: serde_json::Map::new(),
+            provider_trust,
+            caller_key: self.identity.caller_key().clone(),
+            assurance,
+            secret_key: self.identity.transport_key(),
+        })
+    }
+
+    pub async fn fetch(
+        &self,
+        request: &RunRequest,
+    ) -> anyhow::Result<
+        std::pin::Pin<
+            Box<
+                dyn futures::Stream<
+                        Item = hellas_sdk::client::ClientResult<
+                            hellas_sdk::client::FetchExecutionEvent,
+                        >,
+                    > + Send,
+            >,
+        >,
+    > {
+        if !matches!(request.kind, RunKind::Fetch) {
+            bail!("causal-LM execution is not configured in this build")
+        }
+        let (node_id, node_addrs, execution_environment, assurance, provider_trust) =
+            self.remote_fetch_parameters(request)?;
+        let client = self
+            .client
+            .get_or_try_init(|| hellas_sdk::HellasClient::open_with_identity(self.identity.clone()))
+            .await?;
+        client
+            .fetch(hellas_sdk::RemoteFetchRequest {
+                node_id: Some(node_id),
+                node_addrs,
+                retries: 1,
+                service: request.service.clone(),
+                method: request.method.clone(),
+                execution_environment,
+                payload: request.input.as_bytes().to_vec(),
+                retention: hellas_rpc::Retention::Ephemeral,
+                assurance,
+                provider_trust,
+            })
+            .map_err(Into::into)
+    }
+
+    fn remote_fetch_parameters(
+        &self,
+        request: &RunRequest,
+    ) -> anyhow::Result<(
+        hellas_sdk::iroh::EndpointId,
+        Vec<std::net::SocketAddr>,
+        hellas_rpc::ContentId,
+        hellas_rpc::Assurance,
+        hellas_sdk::client::ProviderTrustAnchor,
+    )> {
+        let node_id = request
+            .target
+            .parse()
+            .context("invalid provider endpoint ID")?;
+        let node_addrs = request
+            .node_addresses
+            .iter()
+            .map(|address| address.parse().context("invalid provider socket address"))
+            .collect::<anyhow::Result<Vec<_>>>()?;
+        let expected_genesis = request
+            .trust_anchor
+            .parse()
+            .context("invalid provider genesis content ID")?;
+        let execution_environment = request
+            .execution_environment
+            .parse()
+            .context("invalid execution-environment content ID")?;
+        let assurance = match request.assurance {
+            AssuranceInput::ProducerSigned => hellas_rpc::Assurance::ProducerSigned,
+            AssuranceInput::AppleAppAttest => hellas_rpc::Assurance::AppleAppAttest,
+        };
+        let apple_app_attest = if matches!(request.assurance, AssuranceInput::AppleAppAttest) {
+            if request.apple_app_id.is_empty() || request.apple_cd_hashes.is_empty() {
+                bail!("Apple App Attest requires an app ID and at least one allowed CDHash")
+            }
+            let hashes = request
+                .apple_cd_hashes
+                .iter()
+                .map(|hash| decode_hash(hash))
+                .collect::<anyhow::Result<Vec<_>>>()?;
+            Some(hellas_sdk::client::AppleAppAttestTrust::new(
+                request.apple_app_id.clone(),
+                hashes,
+                Arc::new(hellas_sdk::FilesystemAssertionCounterStore::new(
+                    &self.counter_directory,
+                )),
+            ))
+        } else {
+            None
+        };
+        let provider_trust = hellas_sdk::client::ProviderTrustAnchor {
+            expected_genesis,
+            required_assurance: assurance,
+            apple_app_attest,
+        };
+        Ok((
+            node_id,
+            node_addrs,
+            execution_environment,
+            assurance,
+            provider_trust,
+        ))
+    }
+}
+
+fn stopped(detail: &str) -> ServiceStatus {
+    ServiceStatus {
+        state: ServiceState::Stopped,
+        detail: detail.into(),
+    }
+}
+
+fn decode_hash(value: &str) -> anyhow::Result<[u8; 32]> {
+    if value.len() != 64 {
+        bail!("Apple CDHash must contain exactly 64 hexadecimal characters")
+    }
+    let mut output = [0_u8; 32];
+    for (index, pair) in value.as_bytes().as_chunks::<2>().0.iter().enumerate() {
+        let text = std::str::from_utf8(pair)?;
+        output[index] = u8::from_str_radix(text, 16).context("Apple CDHash is not hexadecimal")?;
+    }
+    Ok(output)
+}
+
+#[cfg(target_os = "macos")]
+fn decode_public_key(value: &str) -> anyhow::Result<hellas_rpc::PublicKey> {
+    if value.len() != 66 {
+        bail!("allowed caller public keys must contain 66 hexadecimal characters")
+    }
+    let mut output = [0_u8; 33];
+    for (index, pair) in value.as_bytes().as_chunks::<2>().0.iter().enumerate() {
+        let text = std::str::from_utf8(pair)?;
+        output[index] =
+            u8::from_str_radix(text, 16).context("allowed caller public key is not hexadecimal")?;
+    }
+    Ok(hellas_rpc::PublicKey::Secp256k1(output))
+}
diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json
new file mode 100644
index 00000000..d5d21a59
--- /dev/null
+++ b/src-tauri/tauri.conf.json
@@ -0,0 +1,42 @@
+{
+  "$schema": "https://schema.tauri.app/config/2",
+  "productName": "Hellas Gate",
+  "version": "0.1.0",
+  "identifier": "ai.hellas.gate",
+  "build": {
+    "beforeDevCommand": "node ui/dev.mjs",
+    "beforeBuildCommand": "tsc --noEmit -p ui/tsconfig.json && node ui/build.mjs",
+    "devUrl": "http://localhost:1420",
+    "frontendDist": "/tmp/hellas-gate-ui-dist"
+  },
+  "app": {
+    "withGlobalTauri": true,
+    "windows": [{
+      "label": "main",
+      "title": "Hellas Gate",
+      "width": 1120,
+      "height": 760,
+      "minWidth": 820,
+      "minHeight": 580,
+      "resizable": true
+    }],
+    "security": {
+      "csp": "default-src 'self'; connect-src ipc: http://ipc.localhost; img-src 'self' asset: http://asset.localhost; style-src 'self' 'unsafe-inline'"
+    }
+  },
+  "bundle": {
+    "active": true,
+    "targets": ["app"],
+    "icon": [
+      "../crates/gui/icons/32x32.png",
+      "../crates/gui/icons/128x128.png",
+      "../crates/gui/icons/128x128@2x.png",
+      "../crates/gui/icons/icon.icns",
+      "../crates/gui/icons/icon.ico"
+    ],
+    "macOS": {
+      "hardenedRuntime": true,
+      "minimumSystemVersion": "14.0"
+    }
+  }
+}
diff --git a/ui/build.mjs b/ui/build.mjs
new file mode 100644
index 00000000..252e025f
--- /dev/null
+++ b/ui/build.mjs
@@ -0,0 +1,20 @@
+import { copyFile, mkdir, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const source = dirname(fileURLToPath(import.meta.url));
+const output = "/tmp/hellas-gate-ui-dist";
+
+await rm(output, { recursive: true, force: true });
+await mkdir(output, { recursive: true });
+await copyFile(join(source, "index.html"), join(output, "index.html"));
+
+const result = spawnSync(
+  "esbuild",
+  [join(source, "src/main.ts"), "--bundle", "--minify", `--outfile=${join(output, "main.js")}`],
+  { stdio: "inherit" },
+);
+
+if (result.error) throw result.error;
+process.exitCode = result.status ?? 1;
diff --git a/ui/dev.mjs b/ui/dev.mjs
new file mode 100644
index 00000000..57e5b81e
--- /dev/null
+++ b/ui/dev.mjs
@@ -0,0 +1,35 @@
+import { copyFile, mkdir, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+
+const source = dirname(fileURLToPath(import.meta.url));
+const output = "/tmp/hellas-gate-ui-dev";
+
+await rm(output, { recursive: true, force: true });
+await mkdir(output, { recursive: true });
+await copyFile(join(source, "index.html"), join(output, "index.html"));
+
+const child = spawn(
+  "esbuild",
+  [
+    join(source, "src/main.ts"),
+    "--bundle",
+    "--sourcemap",
+    `--outfile=${join(output, "main.js")}`,
+    `--servedir=${output}`,
+    "--serve=127.0.0.1:1420",
+  ],
+  { stdio: "inherit" },
+);
+
+for (const signal of ["SIGINT", "SIGTERM"]) {
+  process.once(signal, () => child.kill(signal));
+}
+
+child.on("error", (error) => {
+  throw error;
+});
+child.on("exit", (code, signal) => {
+  process.exitCode = code ?? (signal ? 128 : 1);
+});
diff --git a/ui/index.html b/ui/index.html
new file mode 100644
index 00000000..b6a43df7
--- /dev/null
+++ b/ui/index.html
@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="color-scheme" content="dark" />
+    <title>Hellas Gate</title>
+    <link rel="stylesheet" href="./main.css" />
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="./main.js"></script>
+  </body>
+</html>
diff --git a/ui/src/api.ts b/ui/src/api.ts
new file mode 100644
index 00000000..c076735a
--- /dev/null
+++ b/ui/src/api.ts
@@ -0,0 +1,66 @@
+// This is the only module allowed to cross the Tauri boundary. Views consume
+// typed functions and never spell command names or inspect transport errors.
+import type {
+  ApiError,
+  AppStatus,
+  ExecutionEvent,
+  GatewayAccess,
+  HistoryEntry,
+  ProviderConfig,
+  RunRequest,
+} from "./types.ts";
+
+interface TauriChannel<T> {
+  onmessage: (message: T) => void;
+}
+
+interface TauriCore {
+  invoke<T>(command: string, args?: Record<string, unknown>): Promise<T>;
+  Channel: new <T>() => TauriChannel<T>;
+}
+
+declare global {
+  interface Window {
+    __TAURI__: { core: TauriCore };
+  }
+}
+
+const { Channel, invoke } = window.__TAURI__.core;
+
+function normalizeError(error: unknown): ApiError {
+  if (typeof error === "object" && error !== null) {
+    const candidate = error as Partial<ApiError>;
+    if (typeof candidate.code === "string" && typeof candidate.message === "string") {
+      return { code: candidate.code, message: candidate.message };
+    }
+  }
+  return { code: "internal", message: String(error) };
+}
+
+async function call<T>(command: string, args?: Record<string, unknown>): Promise<T> {
+  try {
+    return await invoke<T>(command, args);
+  } catch (error) {
+    throw normalizeError(error);
+  }
+}
+
+export const api = {
+  status: (): Promise<AppStatus> => call("get_status"),
+  setProvider: (enabled: boolean, config?: ProviderConfig): Promise<AppStatus> =>
+    call("set_provider_enabled", { enabled, config }),
+  setGateway: (enabled: boolean, config?: RunRequest): Promise<AppStatus> =>
+    call("set_gateway_enabled", { enabled, config }),
+  gatewayAccess: (): Promise<GatewayAccess> => call("get_gateway_access"),
+  history: (limit = 100): Promise<HistoryEntry[]> => call("list_history", { limit }),
+  deleteHistory: (id: string): Promise<boolean> => call("delete_history", { id }),
+  clearHistory: (): Promise<number> => call("clear_history"),
+  run: async (
+    request: RunRequest,
+    onEvent: (event: ExecutionEvent) => void,
+  ): Promise<string> => {
+    const channel = new Channel<ExecutionEvent>();
+    channel.onmessage = onEvent;
+    return call("run_request", { request, onEvent: channel });
+  },
+};
diff --git a/ui/src/generated/ApiError.ts b/ui/src/generated/ApiError.ts
new file mode 100644
index 00000000..2363be23
--- /dev/null
+++ b/ui/src/generated/ApiError.ts
@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type ApiError = { code: string, message: string, };
diff --git a/ui/src/generated/AppStatus.ts b/ui/src/generated/AppStatus.ts
new file mode 100644
index 00000000..78f7cc9c
--- /dev/null
+++ b/ui/src/generated/AppStatus.ts
@@ -0,0 +1,5 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { IdentityStatus } from "./IdentityStatus.ts";
+import type { ServiceStatus } from "./ServiceStatus.ts";
+
+export type AppStatus = { version: string, identity: IdentityStatus, provider: ServiceStatus, gateway: ServiceStatus, endpoint: string, socketPath: string, };
diff --git a/ui/src/generated/AssuranceInput.ts b/ui/src/generated/AssuranceInput.ts
new file mode 100644
index 00000000..dd5b796d
--- /dev/null
+++ b/ui/src/generated/AssuranceInput.ts
@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type AssuranceInput = "producerSigned" | "appleAppAttest";
diff --git a/ui/src/generated/ExecutionEvent.ts b/ui/src/generated/ExecutionEvent.ts
new file mode 100644
index 00000000..82cbf67e
--- /dev/null
+++ b/ui/src/generated/ExecutionEvent.ts
@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type ExecutionEvent = { "type": "started", "data": { runId: string, } } | { "type": "output", "data": { text: string, } } | { "type": "verification", "data": { summary: string, } } | { "type": "finished", "data": { runId: string, } } | { "type": "failed", "data": { runId: string, message: string, } };
diff --git a/ui/src/generated/GatewayAccess.ts b/ui/src/generated/GatewayAccess.ts
new file mode 100644
index 00000000..e960239a
--- /dev/null
+++ b/ui/src/generated/GatewayAccess.ts
@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type GatewayAccess = { address: string, bearer: string, };
diff --git a/ui/src/generated/HistoryEntry.ts b/ui/src/generated/HistoryEntry.ts
new file mode 100644
index 00000000..f731f0e3
--- /dev/null
+++ b/ui/src/generated/HistoryEntry.ts
@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type HistoryEntry = { id: string, createdAtMs: number, kind: string, target: string, status: string, request: string, result: string, verification: string, error: string, };
diff --git a/ui/src/generated/IdentityStatus.ts b/ui/src/generated/IdentityStatus.ts
new file mode 100644
index 00000000..ef546584
--- /dev/null
+++ b/ui/src/generated/IdentityStatus.ts
@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type IdentityStatus = { producerId: string, callerPublicKey: string, nodeId: string, attestation: string, detail: string, };
diff --git a/ui/src/generated/ProviderConfig.ts b/ui/src/generated/ProviderConfig.ts
new file mode 100644
index 00000000..2dc70b99
--- /dev/null
+++ b/ui/src/generated/ProviderConfig.ts
@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type ProviderConfig = { service: string, method: string, openaiApiKey: string, allowedCallers: Array<string>, port?: number, };
diff --git a/ui/src/generated/RunKind.ts b/ui/src/generated/RunKind.ts
new file mode 100644
index 00000000..6c1a8ed1
--- /dev/null
+++ b/ui/src/generated/RunKind.ts
@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type RunKind = "causalLm" | "fetch";
diff --git a/ui/src/generated/RunRequest.ts b/ui/src/generated/RunRequest.ts
new file mode 100644
index 00000000..1b029ff2
--- /dev/null
+++ b/ui/src/generated/RunRequest.ts
@@ -0,0 +1,5 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { AssuranceInput } from "./AssuranceInput.ts";
+import type { RunKind } from "./RunKind.ts";
+
+export type RunRequest = { kind: RunKind, target: string, nodeAddresses: Array<string>, input: string, trustAnchor: string, service: string, method: string, executionEnvironment: string, assurance: AssuranceInput, appleAppId: string, appleCdHashes: Array<string>, };
diff --git a/ui/src/generated/ServiceState.ts b/ui/src/generated/ServiceState.ts
new file mode 100644
index 00000000..5ce47e00
--- /dev/null
+++ b/ui/src/generated/ServiceState.ts
@@ -0,0 +1,3 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type ServiceState = "stopped" | "starting" | "running" | "stopping" | "failed";
diff --git a/ui/src/generated/ServiceStatus.ts b/ui/src/generated/ServiceStatus.ts
new file mode 100644
index 00000000..0df3776c
--- /dev/null
+++ b/ui/src/generated/ServiceStatus.ts
@@ -0,0 +1,4 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { ServiceState } from "./ServiceState.ts";
+
+export type ServiceStatus = { state: ServiceState, detail: string, };
diff --git a/ui/src/main.ts b/ui/src/main.ts
new file mode 100644
index 00000000..1328399d
--- /dev/null
+++ b/ui/src/main.ts
@@ -0,0 +1,333 @@
+import "./style.css";
+import { api } from "./api.ts";
+import type {
+  AppStatus,
+  ExecutionEvent,
+  GatewayAccess,
+  HistoryEntry,
+  ProviderConfig,
+  RunKind,
+  RunRequest,
+} from "./types.ts";
+
+type View = "run" | "serve" | "gateway" | "history" | "settings";
+
+const rootElement = document.querySelector<HTMLDivElement>("#app");
+if (!rootElement) throw new Error("missing #app");
+const root = rootElement;
+
+let view: View = "run";
+let status: AppStatus | null = null;
+let history: HistoryEntry[] = [];
+let output = "";
+let runState = "Ready";
+let gatewayAccess: GatewayAccess | null = null;
+
+root.innerHTML = `
+  <div class="shell">
+    <aside>
+      <div class="brand"><span class="mark">Η</span><div>Hellas<small>Gate</small></div></div>
+      <nav>
+        ${navButton("run", "Run")}
+        ${navButton("serve", "Serve")}
+        ${navButton("gateway", "Gateway")}
+        ${navButton("history", "History")}
+        ${navButton("settings", "Settings")}
+      </nav>
+      <div id="rail-status" class="rail-status">Connecting…</div>
+    </aside>
+    <main id="content"></main>
+  </div>`;
+
+root.querySelectorAll<HTMLButtonElement>("[data-view]").forEach((button) => {
+  button.addEventListener("click", () => {
+    view = button.dataset.view as View;
+    render();
+  });
+});
+
+function navButton(id: View, label: string): string {
+  return `<button data-view="${id}">${label}</button>`;
+}
+
+function render(): void {
+  root.querySelectorAll("[data-view]").forEach((element) => {
+    element.classList.toggle("active", (element as HTMLElement).dataset.view === view);
+  });
+  const content = document.querySelector<HTMLElement>("#content");
+  if (!content) return;
+  if (view === "run") renderRun(content);
+  if (view === "serve") renderService(content, "provider");
+  if (view === "gateway") renderService(content, "gateway");
+  if (view === "history") renderHistory(content);
+  if (view === "settings") renderSettings(content);
+}
+
+function renderRun(content: HTMLElement): void {
+  content.innerHTML = `
+    <header><p class="eyebrow">Verified execution</p><h1>Run on Hellas</h1>
+      <p>Choose the peer and trust anchor explicitly. Gate keeps the complete transcript locally.</p></header>
+    <section class="panel composer">
+      <div class="segmented">
+        <button class="selected" data-kind="fetch">Sealed Fetch</button>
+      </div>
+      <div class="field-row">
+        <label>Target<input id="target" placeholder="provider endpoint or relay target" /></label>
+        <label>Trust anchor<input id="trust" placeholder="provider genesis / trusted pin" /></label>
+      </div>
+      <div class="field-row">
+        <label>Execution environment<input id="environment" placeholder="content ID" /></label>
+        <label>Assurance<select id="assurance"><option value="producerSigned">Producer signed</option><option value="appleAppAttest">Apple App Attest</option></select></label>
+      </div>
+      <div class="field-row">
+        <label>Fetch service<input id="service" value="openai" /></label>
+        <label>Fetch method<input id="method" value="responses" /></label>
+      </div>
+      <div class="field-row">
+        <label>Apple app ID<input id="apple-app-id" placeholder="TEAMID.ai.hellas.gate" /></label>
+        <label>Allowed CDHashes<input id="apple-cdhashes" placeholder="hex, comma separated" /></label>
+      </div>
+      <label>OpenAI Responses request<textarea id="input" rows="8" placeholder='{"model":"gpt-5","input":"Hello","stream":true}'></textarea></label>
+      <div class="actions"><span id="run-state" class="muted">${escapeHtml(runState)}</span><button id="run" class="primary">Run</button></div>
+    </section>
+    <section class="panel output"><div class="panel-title">Output</div><pre id="output">${escapeHtml(output || "No execution yet.")}</pre></section>`;
+
+  let kind: RunKind = "fetch";
+  content.querySelectorAll<HTMLButtonElement>("[data-kind]").forEach((button) => {
+    button.addEventListener("click", () => {
+      kind = button.dataset.kind as RunKind;
+      content.querySelectorAll("[data-kind]").forEach((item) => item.classList.remove("selected"));
+      button.classList.add("selected");
+    });
+  });
+  content.querySelector<HTMLButtonElement>("#run")?.addEventListener("click", async () => {
+    const target = value("#target");
+    const trustAnchor = value("#trust");
+    const input = value("#input");
+    output = "";
+    setRunState("Starting…");
+    try {
+      await api.run({
+        kind,
+        target,
+        trustAnchor,
+        input,
+        nodeAddresses: [],
+        executionEnvironment: value("#environment"),
+        service: value("#service"),
+        method: value("#method"),
+        assurance: value("#assurance") === "appleAppAttest" ? "appleAppAttest" : "producerSigned",
+        appleAppId: value("#apple-app-id"),
+        appleCdHashes: value("#apple-cdhashes").split(",").map((item) => item.trim()).filter(Boolean),
+      }, receiveEvent);
+    } catch (error) {
+      setRunState(errorMessage(error));
+    }
+  });
+}
+
+function receiveEvent(event: ExecutionEvent): void {
+  if (event.type === "started") setRunState(`Running ${event.data.runId}`);
+  if (event.type === "output") output += event.data.text;
+  if (event.type === "verification") output += `\n\nVerification: ${event.data.summary}`;
+  if (event.type === "finished") setRunState("Verified and complete");
+  if (event.type === "failed") setRunState(event.data.message);
+  const element = document.querySelector("#output");
+  if (element) element.textContent = output || "No output.";
+}
+
+function renderService(content: HTMLElement, service: "provider" | "gateway"): void {
+  const current = status?.[service];
+  const title = service === "provider" ? "Serve sealed Fetch" : "Loopback gateway";
+  const description = service === "provider"
+    ? "Offer OpenAI Responses through your attested Hellas identity."
+    : "Expose an authenticated OpenAI-compatible endpoint only on this machine.";
+  content.innerHTML = `
+    <header><p class="eyebrow">${service}</p><h1>${title}</h1><p>${description}</p></header>
+    <section class="panel service-card">
+      <div><div class="panel-title">Runtime</div><h2 id="service-state">${escapeHtml(current?.state ?? "stopped")}</h2>
+      <p id="service-detail">${escapeHtml(current?.detail ?? "Loading…")}</p></div>
+      <button id="toggle" class="primary">${current?.state === "running" ? "Stop" : "Start"}</button>
+    </section>
+    ${service === "provider" ? providerForm() : gatewayForm()}`;
+  content.querySelector<HTMLButtonElement>("#toggle")?.addEventListener("click", async () => {
+    try {
+      const running = status?.[service].state === "running";
+      status = service === "provider"
+        ? await api.setProvider(
+            !running,
+            running ? undefined : providerConfig(),
+          )
+        : await api.setGateway(
+            !running,
+            running ? undefined : gatewayConfig(),
+          );
+      gatewayAccess = status.gateway.state === "running" ? await api.gatewayAccess() : null;
+      render();
+      updateRail();
+    } catch (error) {
+      window.alert(errorMessage(error));
+    }
+  });
+}
+
+function providerForm(): string {
+  return `<section class="panel"><div class="panel-title">Provider configuration</div>
+    <div class="field-row"><label>Backend<input value="OpenAI Responses" readonly /></label>
+    <label>OpenAI API key<input id="provider-api-key" type="password" autocomplete="off" /></label></div>
+    <div class="field-row"><label>Fetch service<input id="provider-service" value="openai" /></label>
+    <label>Fetch method<input id="provider-method" value="responses" /></label></div>
+    <label>Allowed caller public keys<textarea id="provider-callers" rows="3" placeholder="one compressed secp256k1 key per line"></textarea></label>
+    <div class="field-row"><label>Port<input id="provider-port" type="number" min="1" max="65535" placeholder="automatic" /></label></div>
+    <p class="muted">The API key crosses the typed IPC boundary once and remains only in native memory for this provider run.</p></section>`;
+}
+
+function providerConfig(): ProviderConfig {
+  const rawPort = value("#provider-port");
+  return {
+    service: value("#provider-service"),
+    method: value("#provider-method"),
+    openaiApiKey: value("#provider-api-key"),
+    allowedCallers: value("#provider-callers").split(/[,\n]/).map((item) => item.trim()).filter(Boolean),
+    port: rawPort ? Number(rawPort) : undefined,
+  };
+}
+
+function gatewayForm(): string {
+  return `<section class="panel"><div class="panel-title">Local access</div>
+    <div class="field-row"><label>Provider endpoint<input id="gateway-target" placeholder="Hellas endpoint ID" /></label>
+    <label>Provider genesis<input id="gateway-trust" placeholder="trusted content ID" /></label></div>
+    <div class="field-row"><label>Execution environment<input id="gateway-environment" placeholder="Fetch manifest content ID" /></label>
+    <label>Assurance<select id="gateway-assurance"><option value="producerSigned">Producer signed</option><option value="appleAppAttest">Apple App Attest</option></select></label></div>
+    <div class="field-row"><label>Fetch service<input id="gateway-service" value="openai" /></label>
+    <label>Fetch method<input id="gateway-method" value="responses" /></label></div>
+    <div class="field-row"><label>Apple app ID<input id="gateway-apple-app-id" placeholder="TEAMID.ai.hellas.gate" /></label>
+    <label>Allowed CDHashes<input id="gateway-apple-cdhashes" placeholder="hex, comma separated" /></label></div>
+    <div class="field-row"><label>Bind address<input value="127.0.0.1 (ephemeral port)" readonly /></label>
+    <label>Backend<input value="Verified sealed Fetch Responses" readonly /></label></div>
+    <p class="muted">A fresh bearer is generated for each running instance.</p>
+    ${gatewayAccess ? `<div class="definition"><div><span>Base URL</span><code>${escapeHtml(gatewayAccess.address)}</code></div><div><span>Bearer</span><code>${escapeHtml(gatewayAccess.bearer)}</code></div></div>` : ""}</section>`;
+}
+
+function gatewayConfig(): RunRequest {
+  return {
+    kind: "fetch",
+    target: value("#gateway-target"),
+    nodeAddresses: [],
+    input: "{}",
+    trustAnchor: value("#gateway-trust"),
+    service: value("#gateway-service"),
+    method: value("#gateway-method"),
+    executionEnvironment: value("#gateway-environment"),
+    assurance: value("#gateway-assurance") === "appleAppAttest" ? "appleAppAttest" : "producerSigned",
+    appleAppId: value("#gateway-apple-app-id"),
+    appleCdHashes: value("#gateway-apple-cdhashes").split(",").map((item) => item.trim()).filter(Boolean),
+  };
+}
+
+function renderHistory(content: HTMLElement): void {
+  content.innerHTML = `<header><p class="eyebrow">Private local data</p><h1>History</h1>
+    <p>Requests, results, verification, and failures stay in Gate unless you explicitly export them.</p></header>
+    <div class="toolbar"><button id="refresh">Refresh</button><button id="clear" class="danger">Clear all</button></div>
+    <section class="history-list">${history.map(historyCard).join("") || '<div class="panel muted">No history.</div>'}</section>`;
+  content.querySelector("#refresh")?.addEventListener("click", loadHistory);
+  content.querySelector("#clear")?.addEventListener("click", async () => {
+    if (!window.confirm("Permanently clear all local Gate history?")) return;
+    await api.clearHistory();
+    await loadHistory();
+  });
+  content.querySelectorAll<HTMLButtonElement>("[data-delete]").forEach((button) => {
+    button.addEventListener("click", async () => {
+      await api.deleteHistory(button.dataset.delete ?? "");
+      await loadHistory();
+    });
+  });
+}
+
+function historyCard(entry: HistoryEntry): string {
+  return `<article class="panel history-card"><div><span class="pill ${escapeHtml(entry.status)}">${escapeHtml(entry.status)}</span>
+    <h3>${escapeHtml(entry.kind)} · ${escapeHtml(entry.target)}</h3><time>${new Date(entry.createdAtMs).toLocaleString()}</time></div>
+    <p>${escapeHtml(entry.request)}</p>${entry.error ? `<p class="error">${escapeHtml(entry.error)}</p>` : ""}
+    <button data-delete="${escapeHtml(entry.id)}">Delete</button></article>`;
+}
+
+function renderSettings(content: HTMLElement): void {
+  const identity = status?.identity;
+  content.innerHTML = `<header><p class="eyebrow">Host</p><h1>Settings & diagnostics</h1></header>
+    <section class="panel definition"><div><span>App Attest</span><strong>${escapeHtml(identity?.attestation ?? "loading")}</strong></div>
+    <p>${escapeHtml(identity?.detail ?? "")}</p><div><span>Local control socket</span><code>${escapeHtml(status?.socketPath ?? "")}</code></div>
+    <div><span>Caller public key</span><code>${escapeHtml(identity?.callerPublicKey ?? "")}</code></div>
+    <div><span>Version</span><strong>${escapeHtml(status?.version ?? "")}</strong></div></section>`;
+}
+
+async function refreshStatus(): Promise<void> {
+  try {
+    status = await api.status();
+    if (status.gateway.state === "running" && !gatewayAccess) {
+      gatewayAccess = await api.gatewayAccess();
+    } else if (status.gateway.state !== "running") {
+      gatewayAccess = null;
+    }
+    updateRail();
+    refreshVisibleStatus();
+  } catch (error) {
+    const rail = document.querySelector("#rail-status");
+    if (rail) rail.textContent = errorMessage(error);
+  }
+}
+
+function refreshVisibleStatus(): void {
+  if (!status) return;
+  if (view === "settings") {
+    render();
+    return;
+  }
+  const service = view === "serve" ? "provider" : view === "gateway" ? "gateway" : null;
+  if (!service) return;
+  const current = status[service];
+  const state = document.querySelector("#service-state");
+  const detail = document.querySelector("#service-detail");
+  const toggle = document.querySelector<HTMLButtonElement>("#toggle");
+  if (state) state.textContent = current.state;
+  if (detail) detail.textContent = current.detail;
+  if (toggle) toggle.textContent = current.state === "running" ? "Stop" : "Start";
+}
+
+async function loadHistory(): Promise<void> {
+  history = await api.history();
+  if (view === "history") render();
+}
+
+function updateRail(): void {
+  const rail = document.querySelector("#rail-status");
+  if (!rail || !status) return;
+  rail.innerHTML = `<i class="dot ${status.provider.state}"></i> Provider ${escapeHtml(status.provider.state)}<br>
+    <i class="dot ${status.gateway.state}"></i> Gateway ${escapeHtml(status.gateway.state)}`;
+}
+
+function value(selector: string): string {
+  return document.querySelector<HTMLInputElement | HTMLTextAreaElement>(selector)?.value.trim() ?? "";
+}
+
+function setRunState(message: string): void {
+  runState = message;
+  const element = document.querySelector("#run-state");
+  if (element) element.textContent = message;
+}
+
+function errorMessage(error: unknown): string {
+  return typeof error === "object" && error !== null && "message" in error
+    ? String((error as { message: unknown }).message)
+    : String(error);
+}
+
+function escapeHtml(value: string): string {
+  return value.replace(/[&<>'"]/g, (character) => ({
+    "&": "&amp;", "<": "&lt;", ">": "&gt;", "'": "&#39;", '"': "&quot;",
+  })[character] ?? character);
+}
+
+render();
+void refreshStatus();
+void loadHistory();
+window.setInterval(refreshStatus, 5_000);
diff --git a/ui/src/style.css b/ui/src/style.css
new file mode 100644
index 00000000..d2fa5540
--- /dev/null
+++ b/ui/src/style.css
@@ -0,0 +1,46 @@
+:root {
+  font-family: Inter, ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  color: #e9ecf2;
+  background: #090b10;
+  font-synthesis: none;
+}
+
+* { box-sizing: border-box; }
+body { margin: 0; min-width: 820px; min-height: 100vh; background: radial-gradient(circle at 75% -20%, #21314a 0, transparent 38%), #090b10; }
+button, input, textarea, select { font: inherit; }
+button { color: inherit; }
+.shell { display: grid; grid-template-columns: 210px 1fr; min-height: 100vh; }
+aside { position: sticky; top: 0; height: 100vh; padding: 28px 18px; border-right: 1px solid #242936; background: rgba(10, 12, 18, .88); }
+.brand { display: flex; gap: 12px; align-items: center; margin: 0 8px 34px; font-weight: 650; letter-spacing: .02em; }
+.brand small { display: block; color: #8992a6; font-weight: 500; }
+.mark { display: grid; place-items: center; width: 38px; height: 38px; border: 1px solid #617ba3; border-radius: 12px; color: #b9cdf0; background: #182131; }
+nav { display: grid; gap: 5px; }
+nav button { padding: 11px 13px; border: 0; border-radius: 9px; text-align: left; color: #9ca5b8; background: transparent; cursor: pointer; }
+nav button:hover, nav button.active { color: white; background: #1a1f2a; }
+.rail-status { position: absolute; bottom: 28px; left: 30px; color: #80899b; font-size: 12px; line-height: 2; }
+.dot { display: inline-block; width: 7px; height: 7px; margin-right: 6px; border-radius: 50%; background: #687083; }
+.dot.running { background: #62d19b; }.dot.failed { background: #f47772; }
+main { width: min(900px, calc(100vw - 250px)); margin: 0 auto; padding: 54px 32px 80px; }
+header { margin-bottom: 28px; } h1 { margin: 4px 0 10px; font-size: clamp(30px, 4vw, 46px); letter-spacing: -.04em; } header p { max-width: 660px; color: #9ba4b6; line-height: 1.55; }
+.eyebrow { margin: 0; color: #82a9e5; font-size: 12px; font-weight: 700; letter-spacing: .14em; text-transform: uppercase; }
+.panel { margin-bottom: 18px; padding: 22px; border: 1px solid #282e3a; border-radius: 15px; background: rgba(20, 23, 31, .88); box-shadow: 0 18px 70px rgba(0,0,0,.18); }
+.panel-title { margin-bottom: 14px; color: #8e98ac; font-size: 12px; font-weight: 700; letter-spacing: .1em; text-transform: uppercase; }
+.field-row { display: grid; grid-template-columns: 1fr 1fr; gap: 14px; }
+label { display: grid; gap: 8px; margin-bottom: 15px; color: #aab2c1; font-size: 13px; }
+input, textarea, select { width: 100%; border: 1px solid #303746; border-radius: 9px; padding: 11px 12px; color: #eef1f7; background: #10131a; outline: none; }
+input:focus, textarea:focus, select:focus { border-color: #6589c1; box-shadow: 0 0 0 3px rgba(83, 122, 182, .15); }
+textarea { resize: vertical; line-height: 1.55; }
+.segmented { display: inline-flex; padding: 3px; margin-bottom: 18px; border-radius: 9px; background: #0d1016; }
+.segmented button { border: 0; border-radius: 7px; padding: 8px 13px; color: #818b9f; background: transparent; cursor: pointer; }
+.segmented button.selected { color: white; background: #252c39; }
+.actions, .service-card, .toolbar { display: flex; align-items: center; justify-content: space-between; gap: 14px; }
+button { border: 1px solid #343b4a; border-radius: 9px; padding: 9px 14px; background: #1a1f29; cursor: pointer; }
+button:hover { border-color: #56637a; }.primary { border-color: #6388c3; color: #07111f; font-weight: 700; background: #8db7f4; }.danger { color: #ffaaa6; }
+.muted, time { color: #7f899d; }.error { color: #ff938d; }
+.output pre { min-height: 100px; margin: 0; white-space: pre-wrap; color: #cdd5e3; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; line-height: 1.55; }
+.service-card h2 { margin: 2px 0 8px; text-transform: capitalize; }.service-card p { color: #939daf; }
+.toolbar { justify-content: flex-end; margin: -10px 0 16px; }
+.history-card h3 { margin: 11px 0 5px; }.history-card > button { float: right; }.history-card p { white-space: pre-wrap; }
+.pill { padding: 4px 8px; border-radius: 99px; color: #aeb7c7; background: #262d39; font-size: 11px; text-transform: uppercase; }.pill.failed { color: #ffaaa6; background: #402225; }.pill.complete { color: #8ae3b6; background: #183329; }
+.definition > div { display: flex; justify-content: space-between; gap: 24px; padding: 13px 0; border-bottom: 1px solid #292f3a; }.definition span { color: #8f98a9; }.definition code { overflow-wrap: anywhere; text-align: right; }
+@media (max-width: 850px) { .shell { grid-template-columns: 170px 1fr; } main { width: 100%; padding-inline: 24px; }.field-row { grid-template-columns: 1fr; } }
diff --git a/ui/src/types.ts b/ui/src/types.ts
new file mode 100644
index 00000000..08b87282
--- /dev/null
+++ b/ui/src/types.ts
@@ -0,0 +1,14 @@
+// Public facade for bindings generated from src-tauri/src/dto.rs and error.rs.
+// Run `make bindings` after changing a Rust boundary type.
+export type { ApiError } from "./generated/ApiError.ts";
+export type { AppStatus } from "./generated/AppStatus.ts";
+export type { AssuranceInput } from "./generated/AssuranceInput.ts";
+export type { ExecutionEvent } from "./generated/ExecutionEvent.ts";
+export type { GatewayAccess } from "./generated/GatewayAccess.ts";
+export type { HistoryEntry } from "./generated/HistoryEntry.ts";
+export type { IdentityStatus } from "./generated/IdentityStatus.ts";
+export type { ProviderConfig } from "./generated/ProviderConfig.ts";
+export type { RunKind } from "./generated/RunKind.ts";
+export type { RunRequest } from "./generated/RunRequest.ts";
+export type { ServiceState } from "./generated/ServiceState.ts";
+export type { ServiceStatus } from "./generated/ServiceStatus.ts";
diff --git a/ui/tsconfig.json b/ui/tsconfig.json
new file mode 100644
index 00000000..5f7b4b89
--- /dev/null
+++ b/ui/tsconfig.json
@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+    "moduleResolution": "Bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "strict": true,
+    "noUncheckedIndexedAccess": true
+  },
+  "include": ["src"]
+}