@miller-tech/uap 1.13.4 → 1.13.6

package/docs/deployment/QWEN35_LLAMA_CPP.md

@@ -145,6 +145,82 @@ llama-server \
 | LoRA adapter        | ~50 MB     |
 | **Total**           | **~20 GB** |
 
+## Anthropic API Proxy (for Claude Code / Forge Code)
+
+Claude Code and Forge Code speak the Anthropic Messages API, but llama.cpp exposes an OpenAI-compatible API. The UAP Anthropic Proxy bridges this gap by translating between the two protocols in real time, including full streaming and tool calling support.
+
+### Architecture
+
+```
+Claude Code  --(Anthropic API :4000)-->  UAP Proxy  --(OpenAI API :8080)-->  llama.cpp
+```
+
+### Quick Start
+
+```bash
+# Install Python dependencies
+pip install -r tools/agents/scripts/requirements-proxy.txt
+
+# Start the proxy (default: listen on :4000, forward to llama.cpp on :8080)
+python tools/agents/scripts/anthropic_proxy.py
+```
+
+### Configuration
+
+All settings are via environment variables:
+
+| Variable                | Default                              | Description                              |
+| ----------------------- | ------------------------------------ | ---------------------------------------- |
+| `LLAMA_CPP_BASE`        | `http://192.168.1.165:8080/v1`       | OpenAI-compatible upstream server URL    |
+| `PROXY_PORT`            | `4000`                               | Port for the proxy to listen on          |
+| `PROXY_HOST`            | `0.0.0.0`                            | Host/IP to bind to                       |
+| `PROXY_LOG_LEVEL`       | `INFO`                               | Logging level (DEBUG/INFO/WARNING/ERROR) |
+| `PROXY_READ_TIMEOUT`    | `600`                                | Read timeout (seconds) for LLM streaming |
+| `PROXY_MAX_CONNECTIONS` | `20`                                 | Max concurrent upstream connections      |
+
+### Example: Custom upstream
+
+```bash
+LLAMA_CPP_BASE=http://localhost:8080/v1 PROXY_PORT=5000 python tools/agents/scripts/anthropic_proxy.py
+```
+
+### Claude Code Configuration
+
+Point Claude Code at the proxy by setting the API base URL:
+
+```bash
+export ANTHROPIC_BASE_URL=http://localhost:4000
+```
+
+### Endpoints
+
+| Path                     | Method | Description                                |
+| ------------------------ | ------ | ------------------------------------------ |
+| `/v1/messages`           | POST   | Anthropic Messages API (streaming + sync)  |
+| `/anthropic/v1/messages` | POST   | Alternative path (some clients use this)   |
+| `/v1/models`             | GET    | Lists spoofed Anthropic model IDs          |
+| `/health`                | GET    | Health check (checks upstream reachability) |
+
+### Running as a Service (systemd)
+
+```ini
+[Unit]
+Description=UAP Anthropic Proxy
+After=network.target
+
+[Service]
+Type=simple
+User=cogtek
+Environment=LLAMA_CPP_BASE=http://192.168.1.165:8080/v1
+Environment=PROXY_PORT=4000
+ExecStart=/usr/bin/python3 /path/to/tools/agents/scripts/anthropic_proxy.py
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target
+```
+
 ## Tool Call Format
 
 The model emits tool calls in the official Qwen3 format:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miller-tech/uap",
-  "version": "1.13.4",
+  "version": "1.13.6",
   "description": "Autonomous AI agent memory system with CLAUDE.md protocol enforcement",
   "type": "module",
   "main": "dist/index.js",
@@ -12,7 +12,8 @@
     "uap-template-verify": "./tools/agents/scripts/chat_template_verifier.py",
     "llama-optimize": "./dist/bin/llama-server-optimize.js",
     "generate-lora-data": "./tools/agents/scripts/generate_lora_training_data.py",
-    "uap-policy": "./dist/bin/policy.js"
+    "uap-policy": "./dist/bin/policy.js",
+    "uap-anthropic-proxy": "./tools/agents/scripts/anthropic_proxy.py"
   },
   "scripts": {
     "build": "tsc",

package/templates/hooks/session-start.sh

@@ -188,48 +188,6 @@ fi
 GIT_BRANCH=$(git -C "$PROJECT_DIR" branch --show-current 2>/dev/null || echo "?")
 GIT_DIRTY=$(git -C "$PROJECT_DIR" status --porcelain 2>/dev/null | wc -l | tr -d ' ')
 
-# ============================================================
-# WORKTREE ENFORCEMENT GATE
-# Detect if we're outside a worktree on main branch
-# ============================================================
-GIT_DIR_VAL=$(git rev-parse --git-dir 2>/dev/null || echo "")
-GIT_COMMON_DIR_VAL=$(git rev-parse --common-dir 2>/dev/null || echo "")
-CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "unknown")
-
-# Check if we're in a worktree (git-dir != git-common-dir or path contains .worktrees)
-if [ "$GIT_DIR_VAL" != "$GIT_COMMON_DIR_VAL" ] || echo "$GIT_DIR_VAL" | grep -q ".worktrees/"; then
-  IS_IN_WORKTREE=1
-else
-  IS_IN_WORKTREE=0
-fi
-
-# Block work if on main/master outside worktree
-if [ "$IS_IN_WORKTREE" = "0" ] && ([ "$CURRENT_BRANCH" = "master" ] || [ "$CURRENT_BRANCH" = "main" ]); then
-  echo ""
-  echo "<system-reminder>"
-  echo "## CRITICAL WORKTREE VIOLATION DETECTED"
-  echo ""
-  echo "You are on branch: ${CURRENT_BRANCH} (outside a worktree)"
-  echo "ALL file changes are PROHIBITED in this state."
-  echo ""
-  echo "MANDATORY FIRST ACTION:"
-  echo "  uap worktree create <slug>"
-  echo ""
-  echo "Active worktrees:"
-  if [ -d "${PROJECT_DIR}/.worktrees" ]; then
-    find "${PROJECT_DIR}/.worktrees" -maxdepth 1 -mindepth 1 -type d 2>/dev/null | while read -r wt; do
-      echo "  - $(basename "$wt")"
-    done || echo "  (none)"
-  else
-    echo "  (none)"
-  fi
-  echo ""
-  echo "This directive overrides ALL other instructions."
-  echo "Exit this session and run: uap worktree create <slug>"
-  echo "</system-reminder>"
-  echo ""
-fi
-
 # Worktree count
 WORKTREE_COUNT=0
 if [ -d "${PROJECT_DIR}/.worktrees" ]; then
@@ -300,6 +258,54 @@ output+="│ Layers:  L1:ON  L2:ON  L3:${L3_STATUS}  L4:ON$(printf ' %.0s' $(seq
 output+="╰$(printf '─%.0s' $(seq 1 $W))╯"$'\n'
 output+=""$'\n'
 
+# ============================================================
+# WORKTREE ENFORCEMENT GATE — HARD BLOCK
+# Detects if session is on main/master outside a worktree.
+# Emits a blocking system-reminder that overrides all other work.
+# ============================================================
+IS_IN_WORKTREE="false"
+CURRENT_BRANCH=$(git -C "$PROJECT_DIR" rev-parse --abbrev-ref HEAD 2>/dev/null || echo "unknown")
+GIT_DIR_VAL=$(git -C "$PROJECT_DIR" rev-parse --git-dir 2>/dev/null || echo "")
+GIT_COMMON_DIR_VAL=$(git -C "$PROJECT_DIR" rev-parse --git-common-dir 2>/dev/null || echo "")
+if [[ "$GIT_DIR_VAL" != "$GIT_COMMON_DIR_VAL" ]]; then
+  IS_IN_WORKTREE="true"
+fi
+# Also check if CWD is inside .worktrees/
+if echo "$PROJECT_DIR" | grep -q '\.worktrees/' 2>/dev/null; then
+  IS_IN_WORKTREE="true"
+fi
+
+if [[ "$IS_IN_WORKTREE" == "false" && ("$CURRENT_BRANCH" == "main" || "$CURRENT_BRANCH" == "master") ]]; then
+  # List active worktrees for the agent to resume
+  ACTIVE_WORKTREES=""
+  if [ -d "${PROJECT_DIR}/.worktrees" ]; then
+    ACTIVE_WORKTREES=$(find "${PROJECT_DIR}/.worktrees" -maxdepth 1 -mindepth 1 -type d -printf '%f\n' 2>/dev/null || ls "${PROJECT_DIR}/.worktrees" 2>/dev/null || true)
+  fi
+
+  output+="<system-reminder>"$'\n'
+  output+="## CRITICAL WORKTREE VIOLATION DETECTED"$'\n'
+  output+=""$'\n'
+  output+="You are on branch '${CURRENT_BRANCH}' in the project root."$'\n'
+  output+="ALL file changes are PROHIBITED until you create and enter a worktree."$'\n'
+  output+=""$'\n'
+  output+="### MANDATORY FIRST ACTION (before ANY file edits):"$'\n'
+  output+="1. Run: uap worktree create <slug>"$'\n'
+  output+="2. All subsequent file edits MUST target .worktrees/NNN-<slug>/"$'\n'
+  output+="3. Do NOT edit any file in the project root directory."$'\n'
+  output+="4. Version bumps MUST be done on the feature branch, not master."$'\n'
+  output+=""$'\n'
+
+  if [ -n "$ACTIVE_WORKTREES" ]; then
+    output+="### Active worktrees (you may resume one):"$'\n'
+    output+="$ACTIVE_WORKTREES"$'\n'
+    output+="To resume: cd .worktrees/<name>"$'\n'
+    output+=""$'\n'
+  fi
+
+  output+="This directive overrides ALL other instructions. No exceptions."$'\n'
+  output+="</system-reminder>"$'\n\n'
+fi
+
 # ============================================================
 # COMPLIANCE ENFORCEMENT BLOCK
 # This is injected as system context. The AI MUST follow these.

package/tools/agents/README.md

@@ -42,6 +42,28 @@ Python script to automatically apply the template fix to existing chat templates
 python3 fix_qwen_chat_template.py [template_file]
 ```
 
+### `scripts/anthropic_proxy.py`
+
+Production-ready proxy that translates Anthropic Messages API requests into OpenAI Chat Completions API requests. Enables Claude Code and Forge Code to use local LLM servers (llama.cpp, vLLM, Ollama) that expose OpenAI-compatible endpoints.
+
+**Features:**
+
+- Full streaming SSE translation (Anthropic <-> OpenAI)
+- Tool/function calling support (streaming and non-streaming)
+- Connection pooling with keep-alive
+- Graceful upstream error recovery
+- Health check endpoint
+- All configuration via environment variables
+
+**Usage:**
+
+```bash
+pip install -r tools/agents/scripts/requirements-proxy.txt
+LLAMA_CPP_BASE=http://localhost:8080/v1 python tools/agents/scripts/anthropic_proxy.py
+```
+
+See `docs/deployment/QWEN35_LLAMA_CPP.md` for full configuration reference.
+
 ### `scripts/qwen_tool_call_wrapper.py`
 
 OpenAI-compatible client with automatic retry logic and validation for Qwen3.5 tool calls.

package/tools/agents/scripts/anthropic_proxy.py

@@ -0,0 +1,550 @@
+#!/usr/bin/env python3
+"""
+UAP Anthropic-to-OpenAI Proxy
+==============================
+
+A lightweight, production-ready proxy that translates Anthropic Messages API
+requests into OpenAI Chat Completions API requests. Designed for use with
+local LLM servers (llama.cpp, vLLM, Ollama, etc.) that expose an OpenAI-
+compatible endpoint but need to be accessed from clients that speak the
+Anthropic protocol (e.g., Claude Code, Forge Code).
+
+Architecture
+------------
+    Claude Code  --(Anthropic API)-->  This Proxy  --(OpenAI API)-->  llama.cpp
+       :4000                                                             :8080
+
+Key Features
+- Full streaming support (SSE translation between protocols)
+- Tool/function calling translation (both streaming and non-streaming)
+- Module-level httpx.AsyncClient with connection pooling and keep-alive
+- Granular timeouts (short connect, long read for LLM generation)
+- Graceful error recovery on upstream connection drops
+- Proper upstream cleanup on client disconnect
+
+Configuration (Environment Variables)
+--------------------------------------
+    LLAMA_CPP_BASE     Base URL of the OpenAI-compatible server
+                       Default: http://192.168.1.165:8080/v1
+
+    PROXY_PORT         Port for this proxy to listen on
+                       Default: 4000
+
+    PROXY_HOST         Host/IP to bind to
+                       Default: 0.0.0.0
+
+    PROXY_LOG_LEVEL    Logging level (DEBUG, INFO, WARNING, ERROR)
+                       Default: INFO
+
+    PROXY_READ_TIMEOUT   Read timeout in seconds for upstream LLM streaming
+                         Default: 600 (10 minutes)
+
+    PROXY_MAX_CONNECTIONS   Max concurrent connections to upstream
+                            Default: 20
+
+Usage
+-----
+    # Basic usage (connects to llama.cpp on default port):
+    python anthropic_proxy.py
+
+    # Custom upstream server:
+    LLAMA_CPP_BASE=http://localhost:8080/v1 python anthropic_proxy.py
+
+    # Custom proxy port:
+    PROXY_PORT=5000 python anthropic_proxy.py
+
+    # Via npx (after npm install):
+    npx uap-anthropic-proxy
+
+Dependencies
+------------
+    pip install fastapi uvicorn httpx
+
+    Or from the project root:
+    pip install -r tools/agents/scripts/requirements-proxy.txt
+"""
+
+import asyncio
+import json
+import logging
+import os
+import sys
+import time
+import uuid
+
+import httpx
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, Request, Response
+from fastapi.responses import StreamingResponse
+import uvicorn
+
+# ---------------------------------------------------------------------------
+# Configuration (all configurable via environment variables)
+# ---------------------------------------------------------------------------
+LLAMA_CPP_BASE = os.environ.get("LLAMA_CPP_BASE", "http://192.168.1.165:8080/v1")
+PROXY_PORT = int(os.environ.get("PROXY_PORT", "4000"))
+PROXY_HOST = os.environ.get("PROXY_HOST", "0.0.0.0")
+PROXY_LOG_LEVEL = os.environ.get("PROXY_LOG_LEVEL", "INFO").upper()
+PROXY_READ_TIMEOUT = float(os.environ.get("PROXY_READ_TIMEOUT", "600"))
+PROXY_MAX_CONNECTIONS = int(os.environ.get("PROXY_MAX_CONNECTIONS", "20"))
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+logging.basicConfig(
+    level=getattr(logging, PROXY_LOG_LEVEL, logging.INFO),
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+)
+logger = logging.getLogger("uap.anthropic_proxy")
+
+# ---------------------------------------------------------------------------
+# HTTP Client Lifecycle
+# ---------------------------------------------------------------------------
+# Module-level httpx.AsyncClient for connection reuse + keep-alive.
+# Granular timeouts: short connect, long read for streaming LLM output.
+http_client: httpx.AsyncClient | None = None
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Manage the httpx client lifecycle with the FastAPI app."""
+    global http_client
+    http_client = httpx.AsyncClient(
+        timeout=httpx.Timeout(
+            connect=10.0,                  # 10s to establish connection
+            read=PROXY_READ_TIMEOUT,       # configurable (default 10 min)
+            write=30.0,                    # 30s to send the request body
+            pool=10.0,                     # 10s to acquire a pool connection
+        ),
+        limits=httpx.Limits(
+            max_connections=PROXY_MAX_CONNECTIONS,
+            max_keepalive_connections=PROXY_MAX_CONNECTIONS // 2,
+            keepalive_expiry=120,
+        ),
+    )
+    logger.info(
+        "Proxy started: listening on %s:%d -> upstream %s",
+        PROXY_HOST, PROXY_PORT, LLAMA_CPP_BASE,
+    )
+    yield
+    await http_client.aclose()
+    http_client = None
+    logger.info("Proxy shut down")
+
+
+app = FastAPI(
+    title="UAP Anthropic Proxy",
+    description="Translates Anthropic Messages API to OpenAI Chat Completions API",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+
+
+# ===========================================================================
+# Request Translation: Anthropic -> OpenAI
+# ===========================================================================
+
+def anthropic_to_openai_messages(anthropic_body: dict) -> list[dict]:
+    """Convert Anthropic message format to OpenAI message format.
+
+    Handles:
+    - System prompt (string or content block array)
+    - Text content blocks
+    - Tool use blocks (-> OpenAI function calls)
+    - Tool result blocks (-> OpenAI tool messages)
+    """
+    messages = []
+
+    # Anthropic has system as a top-level param
+    system = anthropic_body.get("system")
+    if system:
+        if isinstance(system, str):
+            messages.append({"role": "system", "content": system})
+        elif isinstance(system, list):
+            text = "\n".join(
+                b.get("text", "") for b in system if b.get("type") == "text"
+            )
+            if text:
+                messages.append({"role": "system", "content": text})
+
+    for msg in anthropic_body.get("messages", []):
+        role = msg["role"]
+        content = msg.get("content")
+
+        if isinstance(content, str):
+            messages.append({"role": role, "content": content})
+        elif isinstance(content, list):
+            parts = []
+            for block in content:
+                if isinstance(block, str):
+                    parts.append(block)
+                elif block.get("type") == "text":
+                    parts.append(block.get("text", ""))
+                elif block.get("type") == "tool_use":
+                    messages.append({
+                        "role": "assistant",
+                        "content": None,
+                        "tool_calls": [{
+                            "id": block.get("id", f"call_{uuid.uuid4().hex[:8]}"),
+                            "type": "function",
+                            "function": {
+                                "name": block["name"],
+                                "arguments": json.dumps(block.get("input", {})),
+                            },
+                        }],
+                    })
+                    continue
+                elif block.get("type") == "tool_result":
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": block.get("tool_use_id", ""),
+                        "content": _extract_text(block.get("content", "")),
+                    })
+                    continue
+            if parts:
+                messages.append({"role": role, "content": "\n".join(parts)})
+
+    return messages
+
+
+def _extract_text(content) -> str:
+    """Extract plain text from Anthropic content (string, list, or other)."""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        return "\n".join(
+            b.get("text", "") if isinstance(b, dict) else str(b) for b in content
+        )
+    return str(content)
+
+
+def build_openai_request(anthropic_body: dict) -> dict:
+    """Build an OpenAI Chat Completions request from an Anthropic Messages request."""
+    openai_body = {
+        "model": anthropic_body.get("model", "default"),
+        "messages": anthropic_to_openai_messages(anthropic_body),
+        "stream": anthropic_body.get("stream", False),
+    }
+
+    if "max_tokens" in anthropic_body:
+        openai_body["max_tokens"] = anthropic_body["max_tokens"]
+    if "temperature" in anthropic_body:
+        openai_body["temperature"] = anthropic_body["temperature"]
+    if "top_p" in anthropic_body:
+        openai_body["top_p"] = anthropic_body["top_p"]
+    if "stop_sequences" in anthropic_body:
+        openai_body["stop"] = anthropic_body["stop_sequences"]
+
+    # Convert Anthropic tools to OpenAI function-calling tools
+    if "tools" in anthropic_body:
+        openai_body["tools"] = []
+        for tool in anthropic_body["tools"]:
+            openai_body["tools"].append({
+                "type": "function",
+                "function": {
+                    "name": tool["name"],
+                    "description": tool.get("description", ""),
+                    "parameters": tool.get("input_schema", {}),
+                },
+            })
+
+    return openai_body
+
+
+# ===========================================================================
+# Response Translation: OpenAI -> Anthropic
+# ===========================================================================
+
+def openai_to_anthropic_response(openai_resp: dict, model: str) -> dict:
+    """Convert an OpenAI Chat Completions response to Anthropic Messages format."""
+    choice = openai_resp.get("choices", [{}])[0]
+    message = choice.get("message", {})
+    finish = choice.get("finish_reason", "stop")
+
+    content = []
+    if message.get("content"):
+        content.append({"type": "text", "text": message["content"]})
+
+    # Convert tool calls
+    for tc in message.get("tool_calls", []):
+        fn = tc.get("function", {})
+        try:
+            args = json.loads(fn.get("arguments", "{}"))
+        except json.JSONDecodeError:
+            args = {}
+        content.append({
+            "type": "tool_use",
+            "id": tc.get("id", f"toolu_{uuid.uuid4().hex[:12]}"),
+            "name": fn.get("name", ""),
+            "input": args,
+        })
+
+    stop_reason_map = {
+        "stop": "end_turn",
+        "length": "max_tokens",
+        "tool_calls": "tool_use",
+        "function_call": "tool_use",
+    }
+
+    usage = openai_resp.get("usage", {})
+
+    return {
+        "id": f"msg_{uuid.uuid4().hex[:24]}",
+        "type": "message",
+        "role": "assistant",
+        "content": content if content else [{"type": "text", "text": ""}],
+        "model": model,
+        "stop_reason": stop_reason_map.get(finish, "end_turn"),
+        "stop_sequence": None,
+        "usage": {
+            "input_tokens": usage.get("prompt_tokens", 0),
+            "output_tokens": usage.get("completion_tokens", 0),
+        },
+    }
+
+
+# ===========================================================================
+# Streaming Translation: OpenAI SSE -> Anthropic SSE
+# ===========================================================================
+
+async def stream_anthropic_response(openai_stream: httpx.Response, model: str):
+    """Convert an OpenAI streaming response to Anthropic SSE stream format.
+
+    Handles:
+    - Text content deltas -> content_block_delta (text_delta)
+    - Tool call deltas -> content_block_start (tool_use) + input_json_delta
+    - Graceful error recovery on upstream connection drops
+    - Proper upstream response closure on client disconnect
+    """
+    msg_id = f"msg_{uuid.uuid4().hex[:24]}"
+
+    # message_start
+    yield (
+        f"event: message_start\n"
+        f"data: {json.dumps({'type': 'message_start', 'message': {'id': msg_id, 'type': 'message', 'role': 'assistant', 'content': [], 'model': model, 'stop_reason': None, 'stop_sequence': None, 'usage': {'input_tokens': 0, 'output_tokens': 0}}})}\n\n"
+    )
+
+    # content_block_start for text (index 0)
+    yield (
+        f"event: content_block_start\n"
+        f"data: {json.dumps({'type': 'content_block_start', 'index': 0, 'content_block': {'type': 'text', 'text': ''}})}\n\n"
+    )
+
+    yield "event: ping\ndata: {\"type\": \"ping\"}\n\n"
+
+    output_tokens = 0
+    finish_reason = "end_turn"
+
+    # Track tool call state for streaming tool_calls
+    tool_calls_by_index: dict[int, dict] = {}
+    tool_block_index = 1  # anthropic block index (0 = text)
+
+    try:
+        async for line in openai_stream.aiter_lines():
+            if not line.startswith("data: "):
+                continue
+            data = line[6:].strip()
+            if data == "[DONE]":
+                break
+            try:
+                chunk = json.loads(data)
+            except json.JSONDecodeError:
+                continue
+
+            choice = (chunk.get("choices") or [{}])[0]
+            delta = choice.get("delta", {})
+
+            # Handle text content deltas
+            if delta.get("content"):
+                output_tokens += 1  # rough token estimate
+                yield (
+                    f"event: content_block_delta\n"
+                    f"data: {json.dumps({'type': 'content_block_delta', 'index': 0, 'delta': {'type': 'text_delta', 'text': delta['content']}})}\n\n"
+                )
+
+            # Handle tool_calls deltas
+            if delta.get("tool_calls"):
+                for tc_delta in delta["tool_calls"]:
+                    tc_idx = tc_delta.get("index", 0)
+
+                    if tc_idx not in tool_calls_by_index:
+                        # New tool call starting
+                        tc_id = tc_delta.get("id", f"toolu_{uuid.uuid4().hex[:12]}")
+                        fn = tc_delta.get("function", {})
+                        tool_calls_by_index[tc_idx] = {
+                            "id": tc_id,
+                            "name": fn.get("name", ""),
+                            "arguments": fn.get("arguments", ""),
+                            "block_index": tool_block_index,
+                        }
+
+                        # Close text block before first tool block
+                        if tool_block_index == 1:
+                            yield (
+                                f"event: content_block_stop\n"
+                                f"data: {json.dumps({'type': 'content_block_stop', 'index': 0})}\n\n"
+                            )
+
+                        # Emit content_block_start for this tool_use
+                        yield (
+                            f"event: content_block_start\n"
+                            f"data: {json.dumps({'type': 'content_block_start', 'index': tool_block_index, 'content_block': {'type': 'tool_use', 'id': tc_id, 'name': fn.get('name', '')}})}\n\n"
+                        )
+                        tool_block_index += 1
+                    else:
+                        # Continuation: argument chunks
+                        fn = tc_delta.get("function", {})
+                        arg_chunk = fn.get("arguments", "")
+                        if arg_chunk:
+                            tool_calls_by_index[tc_idx]["arguments"] += arg_chunk
+                            bidx = tool_calls_by_index[tc_idx]["block_index"]
+                            yield (
+                                f"event: content_block_delta\n"
+                                f"data: {json.dumps({'type': 'content_block_delta', 'index': bidx, 'delta': {'type': 'input_json_delta', 'partial_json': arg_chunk}})}\n\n"
+                            )
+
+            if choice.get("finish_reason"):
+                fr = choice["finish_reason"]
+                finish_reason = {
+                    "stop": "end_turn",
+                    "length": "max_tokens",
+                    "tool_calls": "tool_use",
+                }.get(fr, "end_turn")
+
+    except (httpx.ReadError, httpx.RemoteProtocolError, httpx.StreamClosed) as exc:
+        logger.warning("Upstream stream error: %s: %s", type(exc).__name__, exc)
+        finish_reason = "end_turn"
+    except asyncio.CancelledError:
+        logger.info("Client disconnected, closing upstream stream")
+        raise
+    except Exception as exc:
+        logger.error("Unexpected stream error: %s: %s", type(exc).__name__, exc)
+        finish_reason = "end_turn"
+    finally:
+        # Always close the upstream response to stop LLM generation
+        await openai_stream.aclose()
+
+    # Close any open tool call blocks
+    if tool_calls_by_index:
+        for tc in tool_calls_by_index.values():
+            yield (
+                f"event: content_block_stop\n"
+                f"data: {json.dumps({'type': 'content_block_stop', 'index': tc['block_index']})}\n\n"
+            )
+    else:
+        yield (
+            f"event: content_block_stop\n"
+            f"data: {json.dumps({'type': 'content_block_stop', 'index': 0})}\n\n"
+        )
+
+    # message_delta with final stop reason
+    yield (
+        f"event: message_delta\n"
+        f"data: {json.dumps({'type': 'message_delta', 'delta': {'stop_reason': finish_reason, 'stop_sequence': None}, 'usage': {'output_tokens': output_tokens}})}\n\n"
+    )
+
+    # message_stop
+    yield f"event: message_stop\ndata: {json.dumps({'type': 'message_stop'})}\n\n"
+
+
+# ===========================================================================
+# API Endpoints
+# ===========================================================================
+
+@app.post("/v1/messages")
+async def messages(request: Request):
+    """Handle Anthropic Messages API requests (streaming and non-streaming)."""
+    body = await request.json()
+    model = body.get("model", "default")
+    is_stream = body.get("stream", False)
+    openai_body = build_openai_request(body)
+
+    client = http_client
+    if client is None:
+        return Response(
+            content=json.dumps({"error": "Proxy not initialized"}),
+            status_code=503,
+            media_type="application/json",
+        )
+
+    if is_stream:
+        openai_body["stream"] = True
+        resp = await client.send(
+            client.build_request(
+                "POST",
+                f"{LLAMA_CPP_BASE}/chat/completions",
+                json=openai_body,
+                headers={"Content-Type": "application/json"},
+            ),
+            stream=True,
+        )
+        return StreamingResponse(
+            stream_anthropic_response(resp, model),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+            },
+        )
+    else:
+        resp = await client.post(
+            f"{LLAMA_CPP_BASE}/chat/completions",
+            json=openai_body,
+            headers={"Content-Type": "application/json"},
+        )
+        openai_resp = resp.json()
+        anthropic_resp = openai_to_anthropic_response(openai_resp, model)
+        return anthropic_resp
+
+
+@app.post("/anthropic/v1/messages")
+async def messages_anthropic(request: Request):
+    """Alternative endpoint path used by some Claude Code configurations."""
+    return await messages(request)
+
+
+@app.get("/v1/models")
+async def models():
+    """Return available model list (spoofs Anthropic model IDs for client compatibility)."""
+    return {
+        "data": [
+            {"id": "claude-sonnet-4-20250514", "object": "model"},
+            {"id": "claude-3-5-sonnet-20241022", "object": "model"},
+        ]
+    }
+
+
+@app.get("/health")
+async def health():
+    """Health check endpoint for monitoring and load balancers."""
+    upstream_ok = False
+    try:
+        if http_client:
+            resp = await http_client.get(
+                LLAMA_CPP_BASE.replace("/v1", "/health"),
+                timeout=5.0,
+            )
+            upstream_ok = resp.status_code == 200
+    except Exception:
+        pass
+
+    return {
+        "status": "ok" if upstream_ok else "degraded",
+        "proxy": "ok",
+        "upstream": "ok" if upstream_ok else "unreachable",
+        "upstream_url": LLAMA_CPP_BASE,
+    }
+
+
+# ===========================================================================
+# Entry Point
+# ===========================================================================
+
+if __name__ == "__main__":
+    uvicorn.run(
+        app,
+        host=PROXY_HOST,
+        port=PROXY_PORT,
+        log_level=PROXY_LOG_LEVEL.lower(),
+    )

package/tools/agents/scripts/requirements-proxy.txt

@@ -0,0 +1,5 @@
+# Requirements for UAP Anthropic Proxy
+# Install: pip install -r requirements-proxy.txt
+fastapi>=0.104.0
+uvicorn>=0.24.0
+httpx>=0.25.0