#Qwen3.5-9B 本地部署与 Claude Code 接入：协议不兼容？手搓一个代理就好啦

# Anthropic system message → OpenAI user message with prefix
messages = []
for m in anthropic_request["messages"]:
    role = m["role"]
    text = flatten_content(m["content"])
    if role == "system":
        messages.append({"role": "user", "content": f"[System]\n{text}"})
    else:
        messages.append({"role": role, "content": text})

anthropic_resp = {
    "id": "msg_" + uuid.uuid4().hex[:12],
    "type": "message",
    "role": "assistant",
    "content": [{"type": "text", "text": text}],
    "model": model,
    "stop_reason": "end_turn",
    "usage": {"input_tokens": ..., "output_tokens": ...}
}

"""Anthropic -> OpenAI 转译代理 v4（含请求日志）"""
import json, http.server, urllib.request, uuid, time, threading

OLLAMA = "http://localhost:11434/v1"
PORT = 8787
LOG_FILE = "proxy.log"

def log(msg):
    ts = time.strftime("%H:%M:%S")
    line = f"[{ts}] {msg}"
    print(line, flush=True)
    with open(LOG_FILE, "a", encoding="utf-8") as f:
        f.write(line + "\n")

def sse(event, data):
    return f"event: {event}\ndata: {json.dumps(data)}\n\n".encode()

class Proxy(http.server.BaseHTTPRequestHandler):
    def log_message(self, fmt, *args):
        log(fmt % args)

    def _respond(self, code, body):
        self.send_response(code)
        self.send_header("Content-Type", "application/json")
        self.end_headers()
        self.wfile.write(json.dumps(body).encode())

    def do_GET(self):
        log(f"GET {self.path}")
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.end_headers()
        if "/models" in self.path:
            try:
                r = urllib.request.urlopen(f"{OLLAMA}/models", timeout=10)
                d = json.loads(r.read())
                models = [{"id": m["id"], "object": "model"} for m in d.get("data", [])]
                self.wfile.write(json.dumps({"object": "list", "data": models}).encode())
            except:
                self.wfile.write(json.dumps({"object": "list", "data": [
                    {"id": "qwen3.5-9b-agent", "object": "model"}
                ]}).encode())
        else:
            self.wfile.write(json.dumps({"status": "ok"}).encode())

    def do_POST(self):
        length = int(self.headers.get("Content-Length", 0))
        raw = self.rfile.read(length)
        req = json.loads(raw)

        # 去掉 query string（如 ?beta=true）
        path = self.path.split("?")[0]
        is_stream = req.get("stream", False)
        model = req.get("model", "qwen3.5-9b-agent")
        log(f"POST {self.path} | model={model} | stream={is_stream} | msgs={len(req.get('messages',[]))} | tools={len(req.get('tools',[]))}")

        if path not in ("/v1/messages", "/anthropic/v1/messages"):
            return self._respond(200, {"status": "ok"})

        # 转换消息格式
        msgs = []
        for m in req.get("messages", []):
            role = m["role"]
            text = self._flatten(m.get("content", ""))
            if role == "system":
                msgs.append({"role": "user", "content": f"[System]\n{text}"})
            else:
                msgs.append({"role": role, "content": text})

        body = {
            "model": model,
            "messages": msgs,
            "max_tokens": req.get("max_tokens", 4096),
            "stream": is_stream,
        }
        log(f"  -> Ollama: {len(msgs)} msgs, max_tokens={body['max_tokens']}")

        try:
            data = json.dumps(body).encode()
            r = urllib.request.urlopen(urllib.request.Request(
                f"{OLLAMA}/chat/completions",
                data=data,
                headers={"Content-Type": "application/json"}
            ), timeout=300)

            if is_stream:
                self._stream(req, r)
            else:
                self._nonstream(req, r)
        except Exception as e:
            log(f"ERROR: {e}")
            self._respond(500, {"error": str(e)})

    def _nonstream(self, req, r):
        resp = json.loads(r.read())
        choice = resp["choices"][0]
        msg = choice["message"]
        text = msg.get("content", "") or msg.get("reasoning", "")
        if msg.get("reasoning") and msg.get("content"):
            text = msg["reasoning"] + "\n\n" + msg["content"]

        body = {
            "id": "msg_" + uuid.uuid4().hex[:12],
            "type": "message",
            "role": "assistant",
            "content": [{"type": "text", "text": text.strip()}],
            "model": req.get("model", "qwen3.5-9b-agent"),
            "stop_reason": "end_turn",
            "stop_sequence": None,
            "usage": {"input_tokens": resp.get("usage",{}).get("prompt_tokens",1),
                      "output_tokens": resp.get("usage",{}).get("completion_tokens",1)}
        }
        log(f"OK nonstream: {len(text)} chars")
        self._respond(200, body)

    def _stream(self, req, r):
        log("STREAM start")
        self.send_response(200)
        self.send_header("Content-Type", "text/event-stream")
        self.send_header("Cache-Control", "no-cache")
        self.end_headers()

        mid = "msg_" + uuid.uuid4().hex[:12]
        model = req.get("model", "qwen3.5-9b-agent")
        out_tok = 0
        started = False
        finish = "end_turn"

        # Anthropic SSE 头部事件
        self.wfile.write(sse("message_start", {
            "type": "message_start",
            "message": {"id": mid, "type": "message", "role": "assistant",
                        "content": [], "model": model, "stop_reason": None,
                        "stop_sequence": None, "usage": {"input_tokens": 0, "output_tokens": 0}}
        }))
        self.wfile.flush()
        time.sleep(0.02)

        self.wfile.write(sse("ping", {"type": "ping"}))
        self.wfile.flush()

        buf = b""
        for chunk in r:
            buf += chunk
            while b"\n" in buf:
                line, buf = buf.split(b"\n", 1)
                line = line.strip()
                if not line or not line.startswith(b"data: "):
                    continue
                if line == b"data: [DONE]":
                    break
                try:
                    d = json.loads(line[6:])
                except:
                    continue

                choices = d.get("choices", [])
                if not choices:
                    continue
                delta = choices[0].get("delta", {})
                content = delta.get("content", "")

                if content:
                    if not started:
                        self.wfile.write(sse("content_block_start", {
                            "type": "content_block_start", "index": 0,
                            "content_block": {"type": "text", "text": ""}
                        }))
                        self.wfile.flush()
                        started = True
                    self.wfile.write(sse("content_block_delta", {
                        "type": "content_block_delta", "index": 0,
                        "delta": {"type": "text_delta", "text": content}
                    }))
                    self.wfile.flush()
                    time.sleep(0.01)

                fr = choices[0].get("finish_reason")
                if fr == "stop":
                    finish = "end_turn"
                elif fr == "length":
                    finish = "max_tokens"
                if d.get("usage", {}).get("completion_tokens"):
                    out_tok = d["usage"]["completion_tokens"]

        if started:
            self.wfile.write(sse("content_block_stop", {"type": "content_block_stop", "index": 0}))
            self.wfile.flush()

        self.wfile.write(sse("message_delta", {
            "type": "message_delta",
            "delta": {"stop_reason": finish, "stop_sequence": None},
            "usage": {"output_tokens": out_tok or 1}
        }))
        self.wfile.flush()

        self.wfile.write(sse("message_stop", {"type": "message_stop"}))
        self.wfile.flush()
        log(f"STREAM done: started={started}, finish={finish}, out_tok={out_tok}")

    def _flatten(self, content):
        if isinstance(content, str):
            return content
        if isinstance(content, list):
            parts = []
            for c in content:
                if isinstance(c, dict):
                    t = c.get("type", "")
                    if t == "text":
                        parts.append(c.get("text", ""))
                    elif t == "tool_use":
                        parts.append(f"[Tool: {c.get('name', '')}({json.dumps(c.get('input',{}))})]")
                    elif t == "tool_result":
                        parts.append(f"[ToolResult: {c.get('content','')}]")
                else:
                    parts.append(str(c))
            return "\n".join(parts)
        return str(content)

if __name__ == "__main__":
    log(f"Proxy started on port {PORT}")
    http.server.HTTPServer(("127.0.0.1", PORT), Proxy).serve_forever()