@mmmbuto/anthmorph 0.1.3 → 0.1.4

package/scripts/anthmorphctl

@@ -27,18 +27,27 @@ usage:
   anthmorphctl status
   anthmorphctl logs
   anthmorphctl print-config
+  anthmorphctl bootstrap claude-code [options]
   anthmorphctl help
 
 options for init:
   --port PORT
   --backend-url URL
   --model MODEL
+  --compat-mode strict|compat
   --reasoning-model MODEL
   --ingress-api-key VALUE
   --allow-origin ORIGIN
   --key-env ENV_NAME
   --api-key VALUE --save-key
 
+options for bootstrap claude-code:
+  --write
+  --base-url URL
+  --token VALUE
+  --model MODEL
+  --timeout-ms MS
+
 notes:
   - by default the API key is not saved; use set key-env or --key-env
   - set key VALUE --save stores the key in the local config file
@@ -63,9 +72,11 @@ save_config() {
   tmp_file=$CONFIG_FILE.tmp
   {
     printf 'BACKEND_PROFILE=%s\n' "${BACKEND_PROFILE:-}"
+    printf 'COMPAT_MODE=%s\n' "${COMPAT_MODE:-strict}"
     printf 'BACKEND_URL=%s\n' "${BACKEND_URL:-}"
-    printf 'MODEL=%s\n' "${MODEL:-}"
+    printf 'PRIMARY_MODEL=%s\n' "${PRIMARY_MODEL:-}"
     printf 'REASONING_MODEL=%s\n' "${REASONING_MODEL:-}"
+    printf 'FALLBACK_MODELS=%s\n' "${FALLBACK_MODELS:-}"
     printf 'PORT=%s\n' "${PORT:-3000}"
     printf 'INGRESS_API_KEY=%s\n' "${INGRESS_API_KEY:-}"
     printf 'ALLOWED_ORIGINS=%s\n' "${ALLOWED_ORIGINS:-}"
@@ -122,6 +133,7 @@ ensure_bin_ready() {
 
   if ! command -v cargo >/dev/null 2>&1; then
     echo "cargo not found and anthmorph binary is missing or outdated" >&2
+    echo "build a Linux binary with scripts/docker_build_linux.sh or install Rust/Cargo locally" >&2
     return 1
   fi
 
@@ -153,7 +165,11 @@ parse_common_init_args() {
         shift 2
         ;;
       --model)
-        MODEL=$2
+        PRIMARY_MODEL=$2
+        shift 2
+        ;;
+      --compat-mode)
+        COMPAT_MODE=$2
         shift 2
         ;;
       --reasoning-model)
@@ -202,9 +218,11 @@ init_cmd() {
   shift
 
   BACKEND_PROFILE=
+  COMPAT_MODE=compat
   BACKEND_URL=
-  MODEL=
+  PRIMARY_MODEL=
   REASONING_MODEL=
+  FALLBACK_MODELS=
   PORT=3000
   INGRESS_API_KEY=
   ALLOWED_ORIGINS=
@@ -216,13 +234,14 @@ init_cmd() {
     chutes)
       BACKEND_PROFILE=chutes
       BACKEND_URL=https://llm.chutes.ai/v1
-      MODEL=Qwen/Qwen3.5-397B-A17B-TEE,zai-org/GLM-5-TEE,deepseek-ai/DeepSeek-V3.2-TEE
+      PRIMARY_MODEL=Qwen/Qwen3.5-397B-A17B-TEE
+      FALLBACK_MODELS=zai-org/GLM-5-TEE,deepseek-ai/DeepSeek-V3.2-TEE
       API_KEY_ENV=CHUTES_API_KEY
       ;;
     minimax)
       BACKEND_PROFILE=openai-generic
       BACKEND_URL=${MINIMAX_BASE_URL:-https://api.minimax.io/v1}
-      MODEL=${MINIMAX_MODEL:-MiniMax-M2.5}
+      PRIMARY_MODEL=${MINIMAX_MODEL:-MiniMax-M2.5}
       API_KEY_ENV=MINIMAX_API_KEY
       ;;
     openai)
@@ -236,7 +255,7 @@ init_cmd() {
 
   parse_common_init_args "$@"
 
-  if [ -z "$BACKEND_URL" ] || [ -z "$MODEL" ] || [ -z "$BACKEND_PROFILE" ]; then
+  if [ -z "$BACKEND_URL" ] || [ -z "$PRIMARY_MODEL" ] || [ -z "$BACKEND_PROFILE" ]; then
     echo "backend profile, backend url and model are required" >&2
     exit 1
   fi
@@ -249,6 +268,112 @@ init_cmd() {
   echo "saved config to $CONFIG_FILE"
 }
 
+bootstrap_claude_code_cmd() {
+  ensure_config
+  load_config
+
+  write_mode=0
+  bootstrap_base_url=
+  bootstrap_token=
+  bootstrap_model=
+  bootstrap_timeout_ms=6000000
+
+  while [ "$#" -gt 0 ]; do
+    case "$1" in
+      --write)
+        write_mode=1
+        shift
+        ;;
+      --base-url)
+        bootstrap_base_url=$2
+        shift 2
+        ;;
+      --token)
+        bootstrap_token=$2
+        shift 2
+        ;;
+      --model)
+        bootstrap_model=$2
+        shift 2
+        ;;
+      --timeout-ms)
+        bootstrap_timeout_ms=$2
+        shift 2
+        ;;
+      *)
+        echo "unknown bootstrap option: $1" >&2
+        exit 1
+        ;;
+    esac
+  done
+
+  [ -n "$bootstrap_base_url" ] || bootstrap_base_url="http://127.0.0.1:${PORT:-3000}"
+  [ -n "$bootstrap_model" ] || bootstrap_model="${PRIMARY_MODEL:-}"
+  [ -n "$bootstrap_token" ] || bootstrap_token="${INGRESS_API_KEY:-anthmorph-local}"
+
+  settings_json=$(BOOTSTRAP_TOKEN="$bootstrap_token" \
+    BOOTSTRAP_BASE_URL="$bootstrap_base_url" \
+    BOOTSTRAP_TIMEOUT_MS="$bootstrap_timeout_ms" \
+    BOOTSTRAP_MODEL="$bootstrap_model" \
+    python3 - <<'PY'
+import json
+import os
+
+model = os.environ["BOOTSTRAP_MODEL"]
+payload = {
+    "env": {
+        "ANTHROPIC_AUTH_TOKEN": os.environ["BOOTSTRAP_TOKEN"],
+        "ANTHROPIC_BASE_URL": os.environ["BOOTSTRAP_BASE_URL"],
+        "API_TIMEOUT_MS": os.environ["BOOTSTRAP_TIMEOUT_MS"],
+        "ANTHROPIC_DEFAULT_HAIKU_MODEL": model,
+        "ANTHROPIC_DEFAULT_SONNET_MODEL": model,
+        "ANTHROPIC_DEFAULT_OPUS_MODEL": model,
+        "CLAUDE_CODE_SUBAGENT_MODEL": model,
+        "ANTHROPIC_SMALL_FAST_MODEL": model,
+    }
+}
+print(json.dumps(payload, indent=2))
+PY
+)
+
+  if [ "$write_mode" -eq 1 ]; then
+    mkdir -p "$HOME/.claude"
+    SETTINGS_FILE="$HOME/.claude/settings.json" SETTINGS_JSON="$settings_json" python3 - <<'PY'
+import json
+import os
+from pathlib import Path
+
+settings_path = Path(os.environ["SETTINGS_FILE"])
+incoming = json.loads(os.environ["SETTINGS_JSON"])
+existing = {}
+if settings_path.exists():
+    try:
+        existing = json.loads(settings_path.read_text())
+    except Exception:
+        existing = {}
+
+merged_env = existing.get("env", {}) if isinstance(existing.get("env"), dict) else {}
+merged_env.update(incoming.get("env", {}))
+existing["env"] = merged_env
+settings_path.write_text(json.dumps(existing, indent=2) + "\n")
+
+claude_json_path = Path.home() / ".claude.json"
+claude_json = {}
+if claude_json_path.exists():
+    try:
+        claude_json = json.loads(claude_json_path.read_text())
+    except Exception:
+        claude_json = {}
+claude_json["hasCompletedOnboarding"] = True
+claude_json_path.write_text(json.dumps(claude_json, indent=2) + "\n")
+PY
+    echo "wrote $HOME/.claude/settings.json"
+    echo "set $HOME/.claude.json onboarding flag"
+  else
+    printf '%s\n' "$settings_json"
+  fi
+}
+
 set_cmd() {
   ensure_config
   load_config
@@ -337,8 +462,9 @@ start_cmd() {
   set -- "$BIN_PATH" \
     --port "$PORT" \
     --backend-profile "$BACKEND_PROFILE" \
+    --compat-mode "${COMPAT_MODE:-strict}" \
     --backend-url "$BACKEND_URL" \
-    --model "$MODEL" \
+    --model "$PRIMARY_MODEL" \
     --api-key "$api_key"
 
   if [ -n "${REASONING_MODEL:-}" ]; then
@@ -410,8 +536,10 @@ status_cmd() {
     fi
   fi
   echo "profile: ${BACKEND_PROFILE:-}"
+  echo "compat_mode: ${COMPAT_MODE:-strict}"
   echo "backend_url: ${BACKEND_URL:-}"
-  echo "model: ${MODEL:-}"
+  echo "primary_model: ${PRIMARY_MODEL:-}"
+  echo "fallback_models: ${FALLBACK_MODELS:-}"
   echo "port: ${PORT:-}"
   if [ -n "${API_KEY_ENV:-}" ]; then
     key_source=env:$API_KEY_ENV
@@ -472,6 +600,20 @@ case "$cmd" in
   print-config)
     print_config_cmd
     ;;
+  bootstrap)
+    shift
+    subcmd=${1:-}
+    case "$subcmd" in
+      claude-code)
+        shift
+        bootstrap_claude_code_cmd "$@"
+        ;;
+      *)
+        echo "unknown bootstrap target: $subcmd" >&2
+        exit 1
+        ;;
+    esac
+    ;;
   help|-h|--help)
     usage
     ;;

package/scripts/docker_build_linux.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+set -eu
+
+SCRIPT_PATH=$(readlink -f -- "$0" 2>/dev/null || printf "%s" "$0")
+ROOT_DIR=$(CDPATH= cd -- "$(dirname -- "$SCRIPT_PATH")/.." && pwd)
+
+docker run --rm \
+  -v "$ROOT_DIR:/work" \
+  -w /work \
+  rust:1.89-bookworm \
+  sh -lc 'export PATH=/usr/local/cargo/bin:$PATH; cargo build --release'

package/scripts/docker_npm_dry_run.sh

@@ -0,0 +1,25 @@
+#!/bin/sh
+set -eu
+
+SCRIPT_PATH=$(readlink -f -- "$0" 2>/dev/null || printf "%s" "$0")
+ROOT_DIR=$(CDPATH= cd -- "$(dirname -- "$SCRIPT_PATH")/.." && pwd)
+MODE=${1:-pack}
+
+case "$MODE" in
+  pack)
+    CMD='npm pack --dry-run'
+    ;;
+  publish)
+    CMD='npm publish --dry-run'
+    ;;
+  *)
+    echo "usage: $0 [pack|publish]" >&2
+    exit 1
+    ;;
+esac
+
+docker run --rm \
+  -v "$ROOT_DIR:/work" \
+  -w /work \
+  node:22-bookworm \
+  sh -lc "$CMD"

package/scripts/docker_release_checks.sh

@@ -0,0 +1,18 @@
+#!/bin/sh
+set -eu
+
+SCRIPT_PATH=$(readlink -f -- "$0" 2>/dev/null || printf "%s" "$0")
+ROOT_DIR=$(CDPATH= cd -- "$(dirname -- "$SCRIPT_PATH")/.." && pwd)
+
+echo "[1/4] Secret scan"
+sh "$ROOT_DIR/scripts/docker_secret_scan.sh"
+
+echo "[2/4] Rust tests"
+sh "$ROOT_DIR/scripts/docker_rust_test.sh"
+
+echo "[3/4] Linux release build"
+sh "$ROOT_DIR/scripts/docker_build_linux.sh"
+
+echo "[4/4] npm dry-runs"
+sh "$ROOT_DIR/scripts/docker_npm_dry_run.sh"
+sh "$ROOT_DIR/scripts/docker_npm_dry_run.sh" publish

package/scripts/docker_rust_test.sh

@@ -0,0 +1,35 @@
+#!/bin/sh
+set -eu
+
+SCRIPT_PATH=$(readlink -f -- "$0" 2>/dev/null || printf "%s" "$0")
+ROOT_DIR=$(CDPATH= cd -- "$(dirname -- "$SCRIPT_PATH")/.." && pwd)
+PAYLOAD_DIR_DEFAULT=/opt/claude-proxy/tests/payloads
+
+set -- docker run --rm -v "$ROOT_DIR:/work" -w /work
+
+if [ -d "${ANTHMORPH_CLAUDE_PAYLOAD_DIR:-$PAYLOAD_DIR_DEFAULT}" ]; then
+  PAYLOAD_DIR_HOST=${ANTHMORPH_CLAUDE_PAYLOAD_DIR:-$PAYLOAD_DIR_DEFAULT}
+  set -- "$@" -v "$PAYLOAD_DIR_HOST:$PAYLOAD_DIR_HOST:ro"
+  ANTHMORPH_CLAUDE_PAYLOAD_DIR=$PAYLOAD_DIR_HOST
+fi
+
+for env_name in \
+  CHUTES_API_KEY \
+  CHUTES_BASE_URL \
+  CHUTES_MODEL \
+  MINIMAX_API_KEY \
+  MINIMAX_BASE_URL \
+  MINIMAX_MODEL \
+  ALIBABA_CODE_API_KEY \
+  ALIBABA_BASE_URL \
+  ALIBABA_MODEL \
+  ANTHMORPH_CLAUDE_PAYLOAD_DIR
+do
+  eval "env_value=\${$env_name-}"
+  if [ -n "${env_value:-}" ]; then
+    set -- "$@" -e "$env_name=$env_value"
+  fi
+done
+
+set -- "$@" rust:1.89-bookworm sh -lc 'export PATH=/usr/local/cargo/bin:$PATH; cargo test -- --nocapture'
+"$@"

package/scripts/docker_secret_scan.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+set -eu
+
+SCRIPT_PATH=$(readlink -f -- "$0" 2>/dev/null || printf "%s" "$0")
+ROOT_DIR=$(CDPATH= cd -- "$(dirname -- "$SCRIPT_PATH")/.." && pwd)
+
+docker run --rm \
+  -v "$ROOT_DIR:/repo" \
+  -w /repo \
+  zricethezav/gitleaks:latest \
+  detect --source . --no-git --redact

package/scripts/postinstall.js

@@ -46,7 +46,16 @@ function ensurePrebuiltPermissions() {
 
 function buildRelease() {
   if (!hasCargo()) {
-    console.error("[anthmorph] cargo not found; cannot build local binary");
+    console.error(
+      [
+        "[anthmorph] cargo not found; cannot build a local Linux/macOS binary.",
+        "[anthmorph] Supported install paths:",
+        "  1. install Rust/Cargo and rerun the install",
+        "  2. run scripts/docker_build_linux.sh from the package checkout",
+        "  3. use Termux on Android/aarch64 to consume the bundled prebuilt",
+        "[anthmorph] See docs/PACKAGING.md for details.",
+      ].join("\n"),
+    );
     process.exit(1);
   }
 

package/scripts/test_claude_code_patterns_real.sh

@@ -0,0 +1,150 @@
+#!/bin/sh
+set -eu
+
+PROFILE=${1:-chutes}
+ROOT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
+PAYLOAD_DIR=${ANTHMORPH_CLAUDE_PAYLOAD_DIR:-/opt/claude-proxy/tests/payloads}
+BIN_PATH=${ANTHMORPH_BIN:-$ROOT_DIR/target/release/anthmorph}
+PORT=${ANTHMORPH_TEST_PORT:-3119}
+LOG_FILE=${ANTHMORPH_TEST_LOG:-$ROOT_DIR/.anthmorph/claude-code-real.log}
+PID_FILE=${ANTHMORPH_TEST_PID:-$ROOT_DIR/.anthmorph/claude-code-real.pid}
+
+mkdir -p "$(dirname -- "$LOG_FILE")"
+
+if [ ! -d "$PAYLOAD_DIR" ]; then
+  echo "payload dir not found: $PAYLOAD_DIR" >&2
+  exit 1
+fi
+
+if [ ! -x "$BIN_PATH" ]; then
+  cargo build --release --quiet
+  BIN_PATH=$ROOT_DIR/target/release/anthmorph
+fi
+
+case "$PROFILE" in
+  chutes)
+    : "${CHUTES_API_KEY:?missing CHUTES_API_KEY}"
+    BACKEND_PROFILE=chutes
+    BACKEND_URL=${CHUTES_BASE_URL:-https://llm.chutes.ai/v1}
+    MODEL=${CHUTES_MODEL:-deepseek-ai/DeepSeek-V3.2-TEE}
+    API_KEY=$CHUTES_API_KEY
+    EXPECT_NO_THINK=0
+    ;;
+  minimax)
+    : "${MINIMAX_API_KEY:?missing MINIMAX_API_KEY}"
+    BACKEND_PROFILE=openai-generic
+    BACKEND_URL=${MINIMAX_BASE_URL:-https://api.minimax.io/v1}
+    MODEL=${MINIMAX_MODEL:-MiniMax-M2.5}
+    API_KEY=$MINIMAX_API_KEY
+    EXPECT_NO_THINK=1
+    ;;
+  *)
+    echo "unsupported profile: $PROFILE" >&2
+    exit 1
+    ;;
+esac
+
+cleanup() {
+  if [ -f "$PID_FILE" ]; then
+    pid=$(cat "$PID_FILE" 2>/dev/null || true)
+    if [ -n "${pid:-}" ]; then
+      kill "$pid" 2>/dev/null || true
+      wait "$pid" 2>/dev/null || true
+    fi
+    rm -f "$PID_FILE"
+  fi
+}
+trap cleanup EXIT INT TERM
+
+"$BIN_PATH" \
+  --port "$PORT" \
+  --backend-profile "$BACKEND_PROFILE" \
+  --compat-mode compat \
+  --backend-url "$BACKEND_URL" \
+  --model "$MODEL" \
+  --api-key "$API_KEY" \
+  >"$LOG_FILE" 2>&1 &
+echo $! > "$PID_FILE"
+
+for _ in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do
+  if curl -fsS "http://127.0.0.1:$PORT/health" >/dev/null 2>&1; then
+    break
+  fi
+  sleep 1
+done
+
+PAYLOADS="
+basic_request.json
+content_blocks_text.json
+content_blocks_mixed.json
+conversation_3_system.json
+conversation_2_followup.json
+conversation_4_tools.json
+tool_result.json
+claude_code_adaptive_thinking.json
+cache_control_request.json
+documents_request.json
+unknown_content_blocks.json
+multi_tool_request.json
+"
+
+passed=0
+quarantined=0
+
+is_retryable() {
+  case "$(printf '%s' "$1" | tr '[:upper:]' '[:lower:]')" in
+    *"maximum capacity"*|*"try again later"*|*"rate limit"*|*"temporarily unavailable"*|*"overloaded"*|*"timeout"*)
+      return 0
+      ;;
+  esac
+  return 1
+}
+
+for payload_name in $PAYLOADS; do
+  payload_file=$PAYLOAD_DIR/$payload_name
+  payload=$(sed "s|{{MODEL}}|$MODEL|g" "$payload_file")
+  response_file=$(mktemp)
+  status=$(curl -sS -N -o "$response_file" -w "%{http_code}" \
+    "http://127.0.0.1:$PORT/v1/messages" \
+    -H 'content-type: application/json' \
+    -d "$payload")
+  body=$(cat "$response_file")
+  rm -f "$response_file"
+
+  if [ "$status" != "200" ]; then
+    if is_retryable "$body" || [ "$status" = "429" ] || [ "$status" -ge 500 ] 2>/dev/null; then
+      echo "QUARANTINE $payload_name status=$status"
+      quarantined=$((quarantined + 1))
+      continue
+    fi
+    echo "FAIL $payload_name status=$status"
+    printf '%s\n' "$body"
+    exit 1
+  fi
+
+  printf '%s' "$body" | grep -q 'event: message_start' || {
+    echo "FAIL $payload_name missing message_start"
+    printf '%s\n' "$body"
+    exit 1
+  }
+  printf '%s' "$body" | grep -q 'event: message_stop' || {
+    echo "FAIL $payload_name missing message_stop"
+    printf '%s\n' "$body"
+    exit 1
+  }
+  if printf '%s' "$body" | grep -q '"choices"'; then
+    echo "FAIL $payload_name leaked OpenAI wire format"
+    printf '%s\n' "$body"
+    exit 1
+  fi
+  if [ "$EXPECT_NO_THINK" = "1" ] && printf '%s' "$body" | grep -q '<think>'; then
+    echo "FAIL $payload_name leaked <think> tags"
+    printf '%s\n' "$body"
+    exit 1
+  fi
+
+  echo "PASS $payload_name"
+  passed=$((passed + 1))
+done
+
+echo "passed=$passed quarantined=$quarantined profile=$PROFILE"

package/src/config.rs

@@ -37,3 +37,36 @@ impl FromStr for BackendProfile {
         }
     }
 }
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
+pub enum CompatMode {
+    Strict,
+    Compat,
+}
+
+impl CompatMode {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            CompatMode::Strict => "strict",
+            CompatMode::Compat => "compat",
+        }
+    }
+
+    pub fn is_strict(self) -> bool {
+        matches!(self, CompatMode::Strict)
+    }
+}
+
+impl FromStr for CompatMode {
+    type Err = String;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        match value.trim().to_ascii_lowercase().as_str() {
+            "strict" => Ok(Self::Strict),
+            "compat" | "compatible" => Ok(Self::Compat),
+            other => Err(format!(
+                "unsupported compat mode '{other}', expected 'strict' or 'compat'"
+            )),
+        }
+    }
+}

package/src/main.rs

@@ -6,7 +6,7 @@ mod transform;
 
 use axum::{routing::post, Extension, Router};
 use clap::Parser;
-use config::BackendProfile;
+use config::{BackendProfile, CompatMode};
 use proxy::{build_cors_layer, Config};
 use reqwest::Client;
 use std::sync::Arc;
@@ -29,6 +29,8 @@ struct Cli {
     api_key: Option<String>,
     #[arg(long, value_enum)]
     backend_profile: Option<BackendProfile>,
+    #[arg(long, value_enum)]
+    compat_mode: Option<CompatMode>,
     #[arg(long)]
     ingress_api_key: Option<String>,
     #[arg(long)]
@@ -48,7 +50,7 @@ async fn main() -> anyhow::Result<()> {
         config.backend_url = url;
     }
     if let Some(m) = cli.model {
-        config.model = m;
+        config.primary_model = m;
     }
     if let Some(m) = cli.reasoning_model {
         config.reasoning_model = Some(m);
@@ -59,6 +61,9 @@ async fn main() -> anyhow::Result<()> {
     if let Some(profile) = cli.backend_profile {
         config.backend_profile = profile;
     }
+    if let Some(mode) = cli.compat_mode {
+        config.compat_mode = mode;
+    }
     if let Some(k) = cli.ingress_api_key {
         config.ingress_api_key = Some(k);
     }
@@ -77,7 +82,8 @@ async fn main() -> anyhow::Result<()> {
     tracing::info!("AnthMorph v{}", env!("CARGO_PKG_VERSION"));
     tracing::info!("Backend URL: {}", config.backend_url);
     tracing::info!("Backend Profile: {}", config.backend_profile.as_str());
-    tracing::info!("Model: {}", config.model);
+    tracing::info!("Compat Mode: {}", config.compat_mode.as_str());
+    tracing::info!("Primary Model: {}", config.primary_model);
     if let Some(ref m) = config.reasoning_model {
         tracing::info!("Reasoning Model: {}", m);
     }
@@ -93,6 +99,11 @@ async fn main() -> anyhow::Result<()> {
 
     let app = Router::new()
         .route("/v1/messages", post(proxy::proxy_handler))
+        .route(
+            "/v1/messages/count_tokens",
+            post(proxy::count_tokens_handler),
+        )
+        .route("/v1/models", axum::routing::get(proxy::models_handler))
         .route("/health", axum::routing::get(health_handler))
         .layer(Extension(config.clone()))
         .layer(Extension(client))
@@ -115,6 +126,14 @@ async fn main() -> anyhow::Result<()> {
     Ok(())
 }
 
-async fn health_handler() -> &'static str {
-    "OK"
+async fn health_handler(
+    Extension(config): Extension<Arc<Config>>,
+) -> axum::Json<serde_json::Value> {
+    axum::Json(serde_json::json!({
+        "status": "ok",
+        "backend_profile": config.backend_profile.as_str(),
+        "compat_mode": config.compat_mode.as_str(),
+        "resolved_model": config.primary_model,
+        "port": config.port,
+    }))
 }