@agentunion/kite 1.4.0 → 1.5.0

package/extensions/services/proxy/evol/server/openclaw_proxy.py

@@ -0,0 +1,1861 @@
+"""
+OpenClaw Proxy - OpenAI-compatible API endpoint that forwards to Claude via AgentCP
+"""
+import json
+import time
+import asyncio
+import logging
+import httpx
+from typing import Any, AsyncGenerator, Dict, List, Tuple
+from urllib.parse import unquote
+from starlette.responses import JSONResponse, StreamingResponse, Response
+from starlette.requests import Request
+
+from ..presenter import configPresenter
+from . import claude_proxy_async
+from agentcp.base.log import log_info, log_error
+from agentcp.agentcp import AgentID
+
+logger = logging.getLogger(__name__)
+
+# ============================================================================
+# OpenClaw 独立的 Session Manager 和 AgentID
+# 完全独立于 claude_proxy，不共享任何资源
+# ============================================================================
+
+# OpenClaw 专用的 AgentID 实例
+openclaw_agentId: AgentID = None
+
+# OpenClaw 专用的 AsyncSessionManager 实例
+openclaw_session_manager = None
+
+
+def set_openclaw_agentid(aid: AgentID):
+    """Compatibility hook: OpenClaw now uses shared Claude session manager."""
+    global openclaw_agentId, openclaw_session_manager
+    openclaw_agentId = aid
+    # Shared-session mode: keep isolated manager disabled.
+    openclaw_session_manager = None
+    log_info(f"[OpenClaw] Shared-session mode initialized, AgentID: {aid.id if aid else 'None'}")
+
+
+class OpenClawSessionManager:
+    """OpenClaw 专用的 Session 管理器 - 完全独立于 claude_proxy"""
+
+    def __init__(self):
+        import uuid
+        self._instance_id = str(uuid.uuid4())[:8]
+        logger.debug(f"[OpenClawSessionManager] 初始化实例 ID: {self._instance_id}")
+
+        self._sessions = {}  # api_key -> session_id
+        self._session_info = {}  # session_id -> {'created_time', 'last_used', 'api_key'}
+        self._lock = asyncio.Lock()
+        self._session_timeout = 1800  # 30分钟
+        self._last_cleanup = time.time()
+
+        # trace_id 匹配机制
+        self._pending_requests = {}  # trace_id -> asyncio.Event
+        self._request_result_map = {}  # trace_id -> {"result_type": str, "result": dict}
+        self._handler_registered = {}  # session_id -> bool
+        self._request_timestamps = {}  # trace_id -> timestamp
+
+    async def get_session(self, api_key: str, agent_id: AgentID) -> str:
+        """获取或创建 session"""
+        async with self._lock:
+            current_time = time.time()
+
+            # 检查现有 session
+            if api_key in self._sessions:
+                session_id = self._sessions[api_key]
+                if session_id in self._session_info:
+                    session_data = self._session_info[session_id]
+                    if current_time - session_data['last_used'] < self._session_timeout:
+                        session_data['last_used'] = current_time
+                        if session_id not in self._handler_registered:
+                            await self._setup_handler(session_id, agent_id)
+                        log_info(f"[OpenClaw] 复用 session: {session_id}")
+                        return session_id
+                    else:
+                        await self._remove_session(api_key, session_id, agent_id)
+
+            # 创建新 session
+            session_id = await asyncio.to_thread(
+                agent_id.create_session, "openclaw_proxy", "openclaw_proxy"
+            )
+
+            if session_id:
+                # 邀请 openclaw.aid.pub
+                await asyncio.to_thread(
+                    agent_id.invite_member, session_id, "openclaw.aid.pub"
+                )
+
+                self._sessions[api_key] = session_id
+                self._session_info[session_id] = {
+                    'created_time': current_time,
+                    'last_used': current_time,
+                    'api_key': api_key
+                }
+
+                await self._setup_handler(session_id, agent_id)
+                log_info(f"[OpenClaw] 创建新 session: {session_id}")
+                return session_id
+            else:
+                log_error(f"[OpenClaw] 创建 session 失败")
+                return None
+
+    async def _setup_handler(self, session_id: str, agent_id: AgentID):
+        """设置消息处理器"""
+        # ✅ 捕获主事件循环引用，用于跨线程安全通知
+        main_loop = asyncio.get_running_loop()
+
+        def _threadsafe_set_event(event):
+            """线程安全地设置 asyncio.Event"""
+            try:
+                main_loop.call_soon_threadsafe(event.set)
+            except RuntimeError:
+                event.set()
+
+        async def reply_handler(reply_msg):
+            try:
+                if reply_msg is None:
+                    return
+
+                messages = agent_id.get_content_array_from_message(reply_msg)
+                if not messages:
+                    return
+
+                response_msg = messages[0]
+                if not isinstance(response_msg, dict):
+                    return
+
+                trace_id = response_msg.get("trace_id", "")
+                msg_type = response_msg.get("type", "")
+
+                # 无 trace_id 的错误消息广播给所有等待请求
+                if not trace_id and msg_type == "error":
+                    log_error(f"[OpenClaw] 收到无 trace_id 的错误消息")
+                    error_result = {"result_type": "error", "result": response_msg}
+                    for pending_trace_id in list(self._pending_requests.keys()):
+                        self._request_result_map[pending_trace_id] = error_result
+                        event = self._pending_requests.get(pending_trace_id)
+                        if event:
+                            _threadsafe_set_event(event)
+                    return
+
+                if not trace_id:
+                    return
+
+                # 存储结果并通知
+                result = {"result_type": msg_type, "result": response_msg}
+                self._request_result_map[trace_id] = result
+
+                event = self._pending_requests.get(trace_id)
+                if event:
+                    _threadsafe_set_event(event)
+            except Exception as e:
+                log_error(f"[OpenClaw Handler] 异常: {e}")
+
+        try:
+            await asyncio.to_thread(
+                agent_id.add_message_handler, reply_handler, session_id=session_id
+            )
+            self._handler_registered[session_id] = True
+        except Exception as e:
+            log_error(f"[OpenClaw] Handler 注册失败: {e}")
+
+    async def _remove_session(self, api_key: str, session_id: str, agent_id: AgentID):
+        """移除 session"""
+        try:
+            if agent_id:
+                await asyncio.to_thread(agent_id.close_session, session_id)
+            if api_key in self._sessions:
+                del self._sessions[api_key]
+            if session_id in self._session_info:
+                del self._session_info[session_id]
+            if session_id in self._handler_registered:
+                del self._handler_registered[session_id]
+        except Exception as e:
+            log_error(f"[OpenClaw] 移除 session 失败: {e}")
+
+    def register_request_timestamp(self, trace_id: str):
+        """注册请求时间戳"""
+        self._request_timestamps[trace_id] = time.time()
+
+
+# Supported models list
+SUPPORTED_MODELS = [
+    {
+        "id": "claude-opus-4-6",
+        "object": "model",
+        "created": 1704067200,
+        "owned_by": "anthropic"
+    },
+    {
+        "id": "claude-sonnet-4-6",
+        "object": "model",
+        "created": 1704067200,
+        "owned_by": "anthropic"
+    },
+    {
+        "id": "claude-haiku-4-5-20251001",
+        "object": "model",
+        "created": 1704067200,
+        "owned_by": "anthropic"
+    },
+    {
+        "id": "claude-opus-4-5-20251101",
+        "object": "model",
+        "created": 1704067200,
+        "owned_by": "anthropic"
+    },
+    {
+        "id": "claude-sonnet-4-5-20250929",
+        "object": "model",
+        "created": 1704067200,
+        "owned_by": "anthropic"
+    },
+    {
+        "id": "gpt-5.4",
+        "object": "model",
+        "created": 1704067200,
+        "owned_by": "openai"
+    },
+    {
+        "id": "gpt-5.3-codex",
+        "object": "model",
+        "created": 1704067200,
+        "owned_by": "openai"
+    },
+    {
+        "id": "gpt-5.2",
+        "object": "model",
+        "created": 1704067200,
+        "owned_by": "openai"
+    }
+]
+
+# Model name mapping: OpenAI-style names to Claude API names
+# Note: These simplified names are kept as-is since openclaw.aid.pub handles the mapping
+MODEL_NAME_MAPPING = {
+    "claude-sonnet-4-6": "claude-sonnet-4-6",
+    "claude-opus-4-6": "claude-opus-4-6",
+    "claude-haiku-4-5-20251001": "claude-haiku-4-5-20251001",
+    "claude-opus-4-5-20251101": "claude-opus-4-5-20251101",
+}
+
+
+def normalize_model_name(model: str) -> str:
+    """
+    Normalize model name for Claude API
+    The openclaw.aid.pub service handles the actual model name mapping
+    """
+    return MODEL_NAME_MAPPING.get(model, model)
+
+
+def is_model_supported(model: str) -> bool:
+    """Check if the model is in the supported models list"""
+    return any(m["id"] == model for m in SUPPORTED_MODELS)
+
+
+def get_models_list() -> dict:
+    """Return OpenAI-formatted models list"""
+    return {
+        "object": "list",
+        "data": SUPPORTED_MODELS
+    }
+
+
+def is_claude_model(model: str) -> bool:
+    """Check if model is a Claude model"""
+    model_lower = model.lower()
+    return any(prefix in model_lower for prefix in ['claude-', 'claude_', 'anthropic/', 'anthropic.'])
+
+
+def is_gpt_model(model: str) -> bool:
+    """Check if model is a GPT/Codex model"""
+    model_lower = model.lower()
+    return any(prefix in model_lower for prefix in ['gpt-', 'gpt_', 'codex', 'openai/'])
+
+
+def openai_error_response(message: str, error_type: str = "invalid_request_error", code: str = None, status_code: int = 400) -> JSONResponse:
+    """Return OpenAI-formatted error response"""
+    error_body = {
+        "error": {
+            "message": message,
+            "type": error_type,
+            "code": code
+        }
+    }
+    return JSONResponse(error_body, status_code=status_code)
+
+
+def normalize_openclaw_error_message(response_msg: Any) -> tuple[str, int]:
+    """Normalize upstream OpenClaw errors to a user-facing message."""
+    if isinstance(response_msg, dict):
+        error_message = response_msg.get("content", "Unknown error")
+        http_status = response_msg.get("http_status", 503)
+        trace_id = response_msg.get("trace_id")
+    else:
+        error_message = str(response_msg)
+        http_status = 503
+        trace_id = None
+
+    error_text = str(error_message or "").strip()
+    normalized_text = error_text.lower()
+
+    if not trace_id:
+        return "服务暂不可用，请联系客服处理", 503
+
+    if "offline" in normalized_text:
+        return "服务暂不可用，请联系客服处理", 503
+
+    return error_text or "服务暂不可用，请联系客服处理", int(http_status or 503)
+
+
+def _to_input_parts(content: Any) -> List[dict]:
+    """Convert system/user/developer chat content to Responses API input parts."""
+    if isinstance(content, str):
+        return [{"type": "input_text", "text": content}]
+
+    if not isinstance(content, list):
+        return [{"type": "input_text", "text": str(content) if content is not None else ""}]
+
+    parts: List[dict] = []
+    for block in content:
+        if not isinstance(block, dict):
+            parts.append({"type": "input_text", "text": str(block)})
+            continue
+
+        block_type = block.get("type")
+        if block_type == "text":
+            parts.append({"type": "input_text", "text": block.get("text", "")})
+        elif block_type == "image_url":
+            image_url = block.get("image_url", {})
+            if isinstance(image_url, dict):
+                url = image_url.get("url", "")
+            else:
+                url = str(image_url)
+            parts.append({"type": "input_image", "image_url": url})
+        else:
+            # Keep unknown blocks as plain text to avoid dropping user context.
+            parts.append({"type": "input_text", "text": json.dumps(block, ensure_ascii=False)})
+
+    return parts
+
+
+def _to_assistant_output_parts(content: Any) -> List[dict]:
+    """Convert assistant chat content to Responses API output parts."""
+    if isinstance(content, str):
+        return [{"type": "output_text", "text": content}]
+
+    if content is None:
+        return []
+
+    if not isinstance(content, list):
+        return [{"type": "output_text", "text": str(content)}]
+
+    parts: List[dict] = []
+    for block in content:
+        if not isinstance(block, dict):
+            parts.append({"type": "output_text", "text": str(block)})
+            continue
+
+        block_type = block.get("type")
+        if block_type in ("text", "output_text"):
+            parts.append({"type": "output_text", "text": block.get("text", "")})
+        elif block_type == "refusal":
+            refusal_text = block.get("refusal")
+            if refusal_text is None:
+                refusal_text = block.get("text", "")
+            parts.append({"type": "refusal", "refusal": str(refusal_text)})
+        else:
+            # Assistant input blocks only support output_text/refusal.
+            parts.append({"type": "output_text", "text": json.dumps(block, ensure_ascii=False)})
+
+    return parts
+
+
+def _convert_messages_to_responses_input(messages: List[dict]) -> List[dict]:
+    """Convert OpenAI chat messages[] to Responses API input[] items."""
+    input_items: List[dict] = []
+
+    for msg in messages:
+        role = msg.get("role")
+        content = msg.get("content")
+
+        if role in ("system", "user", "developer"):
+            message_item = {
+                "type": "message",
+                "role": role,
+                "content": _to_input_parts(content)
+            }
+            input_items.append(message_item)
+
+        elif role == "assistant":
+            assistant_parts = _to_assistant_output_parts(content)
+
+            # Chat Completions may include top-level refusal on assistant messages.
+            refusal_text = msg.get("refusal")
+            if refusal_text:
+                assistant_parts.append({"type": "refusal", "refusal": str(refusal_text)})
+
+            # Skip empty assistant messages (e.g. tool_calls-only turns).
+            if assistant_parts:
+                input_items.append({
+                    "type": "message",
+                    "role": "assistant",
+                    "content": assistant_parts
+                })
+
+            # Carry forward assistant tool calls as explicit function_call items.
+            for tool_call in msg.get("tool_calls", []):
+                if tool_call.get("type") != "function":
+                    continue
+                func = tool_call.get("function", {})
+                input_items.append({
+                    "type": "function_call",
+                    "call_id": tool_call.get("id", ""),
+                    "name": func.get("name", ""),
+                    "arguments": func.get("arguments", "{}")
+                })
+
+        elif role == "tool":
+            tool_call_id = msg.get("tool_call_id", "")
+            tool_output = content if isinstance(content, str) else json.dumps(content, ensure_ascii=False)
+            input_items.append({
+                "type": "function_call_output",
+                "call_id": tool_call_id,
+                "output": tool_output
+            })
+
+    return input_items
+
+
+def _convert_tools_to_responses_format(tools: List[dict]) -> List[dict]:
+    """Convert OpenAI chat tool schema to Responses API function tool schema."""
+    response_tools: List[dict] = []
+    for tool in tools:
+        if tool.get("type") != "function":
+            continue
+        fn = tool.get("function", {})
+        response_tools.append({
+            "type": "function",
+            "name": fn.get("name", ""),
+            "description": fn.get("description", ""),
+            "parameters": fn.get("parameters", {})
+        })
+    return response_tools
+
+
+def convert_openai_to_response_format(body: dict) -> dict:
+    """Convert OpenAI /v1/chat/completions payload to Responses API payload."""
+    response_body: Dict[str, Any] = {
+        "model": body.get("model", "gpt-5.3-codex"),
+        "input": _convert_messages_to_responses_input(body.get("messages", [])),
+        "stream": body.get("stream", False),
+    }
+
+    # Optional parameters
+    if "max_tokens" in body:
+        response_body["max_output_tokens"] = body["max_tokens"]
+    elif "max_completion_tokens" in body:
+        response_body["max_output_tokens"] = body["max_completion_tokens"]
+
+    if "temperature" in body:
+        response_body["temperature"] = body["temperature"]
+
+    if "top_p" in body:
+        response_body["top_p"] = body["top_p"]
+
+    if "stop" in body:
+        response_body["stop"] = body["stop"]
+
+    if "tools" in body:
+        converted_tools = _convert_tools_to_responses_format(body["tools"])
+        if converted_tools:
+            response_body["tools"] = converted_tools
+
+    if "tool_choice" in body:
+        tool_choice = body["tool_choice"]
+        if isinstance(tool_choice, dict) and tool_choice.get("type") == "function":
+            fn_name = tool_choice.get("function", {}).get("name")
+            if fn_name:
+                response_body["tool_choice"] = {"type": "function", "name": fn_name}
+        else:
+            response_body["tool_choice"] = tool_choice
+
+    if "frequency_penalty" in body:
+        response_body["frequency_penalty"] = body["frequency_penalty"]
+
+    if "presence_penalty" in body:
+        response_body["presence_penalty"] = body["presence_penalty"]
+
+    if "n" in body:
+        response_body["n"] = body["n"]
+
+    if "user" in body:
+        response_body["user"] = body["user"]
+
+    return response_body
+
+
+def _usage_to_openai_usage(response_body: dict) -> dict:
+    usage = response_body.get("usage", {}) or {}
+    prompt_tokens = usage.get("prompt_tokens", usage.get("input_tokens", 0))
+    completion_tokens = usage.get("completion_tokens", usage.get("output_tokens", 0))
+    total_tokens = usage.get("total_tokens", prompt_tokens + completion_tokens)
+    return {
+        "prompt_tokens": prompt_tokens,
+        "completion_tokens": completion_tokens,
+        "total_tokens": total_tokens
+    }
+
+
+def _extract_response_text_and_tools(response_body: dict) -> Tuple[str, List[dict]]:
+    text_parts: List[str] = []
+    tool_calls: List[dict] = []
+    output = response_body.get("output", [])
+
+    if isinstance(output, list):
+        for item in output:
+            if not isinstance(item, dict):
+                continue
+            item_type = item.get("type")
+
+            if item_type == "message":
+                for part in item.get("content", []):
+                    if not isinstance(part, dict):
+                        continue
+                    part_type = part.get("type")
+                    if part_type in ("output_text", "text", "input_text"):
+                        text_parts.append(part.get("text", ""))
+            elif item_type in ("function_call", "tool_call"):
+                raw_arguments = item.get("arguments", item.get("arguments_json", item.get("input", "")))
+                if isinstance(raw_arguments, (dict, list)):
+                    arguments_str = json.dumps(raw_arguments, ensure_ascii=False)
+                elif raw_arguments is None:
+                    arguments_str = ""
+                else:
+                    arguments_str = str(raw_arguments)
+                tool_calls.append({
+                    "id": item.get("call_id", item.get("id", "")),
+                    "type": "function",
+                    "function": {
+                        "name": item.get("name", ""),
+                        "arguments": arguments_str
+                    }
+                })
+
+    if not text_parts:
+        fallback_content = response_body.get("content", "")
+        if isinstance(fallback_content, list):
+            for block in fallback_content:
+                if isinstance(block, dict):
+                    text_parts.append(block.get("text", ""))
+                else:
+                    text_parts.append(str(block))
+        elif isinstance(fallback_content, str):
+            text_parts.append(fallback_content)
+        elif fallback_content is not None:
+            text_parts.append(str(fallback_content))
+
+    return "".join(text_parts), tool_calls
+
+
+def convert_response_to_openai_format(response_body: dict, model: str) -> dict:
+    """Convert Responses API payload back to OpenAI chat completions format."""
+    # If response is already in OpenAI format (has 'choices' field), return as-is.
+    if "choices" in response_body:
+        return response_body
+
+    # Some providers wrap the actual response object.
+    if isinstance(response_body.get("response"), dict):
+        inner = response_body["response"]
+        if "output" in inner or "usage" in inner:
+            response_body = inner
+
+    message_id = response_body.get("id", f"chatcmpl-{int(time.time())}")
+    created = response_body.get("created", int(time.time()))
+    content_text, tool_calls = _extract_response_text_and_tools(response_body)
+
+    message: Dict[str, Any] = {
+        "role": "assistant",
+        "content": content_text or None
+    }
+    if tool_calls:
+        message["tool_calls"] = tool_calls
+
+    finish_reason = "tool_calls" if tool_calls else "stop"
+
+    return {
+        "id": message_id,
+        "object": "chat.completion",
+        "created": created,
+        "model": model,
+        "choices": [{
+            "index": 0,
+            "message": message,
+            "finish_reason": finish_reason
+        }],
+        "usage": _usage_to_openai_usage(response_body)
+    }
+
+
+def _to_unix_seconds(value: Any, default: int) -> int:
+    if value is None:
+        return default
+    try:
+        number = float(value)
+        if number > 10_000_000_000:  # likely ms timestamp
+            number = number / 1000.0
+        return int(number)
+    except Exception:
+        return default
+
+
+def convert_openai_to_claude_request(body: dict) -> dict:
+    """Convert OpenAI chat completion request to Claude messages format"""
+    claude_body = {}
+
+    # Extract system messages
+    system_messages = []
+    messages = []
+
+    for msg in body.get("messages", []):
+        role = msg.get("role")
+        content = msg.get("content")
+
+        if role == "system":
+            if isinstance(content, str):
+                system_messages.append(content)
+            elif isinstance(content, list):
+                # Handle array content for system messages
+                text_parts = [block.get("text", "") for block in content if block.get("type") == "text"]
+                system_messages.append("".join(text_parts))
+
+        elif role == "user":
+            # Convert user message
+            claude_msg = {"role": "user"}
+            if isinstance(content, str):
+                claude_msg["content"] = content
+            elif isinstance(content, list):
+                # Handle multimodal content
+                claude_content = []
+                for block in content:
+                    if block.get("type") == "text":
+                        claude_content.append({"type": "text", "text": block.get("text", "")})
+                    elif block.get("type") == "image_url":
+                        # Convert OpenAI image_url to Claude image format
+                        image_url = block.get("image_url", {})
+                        url = image_url.get("url", "")
+                        if url.startswith("data:"):
+                            # Base64 image
+                            parts = url.split(",", 1)
+                            if len(parts) == 2:
+                                media_type = parts[0].split(":")[1].split(";")[0]
+                                data = parts[1]
+                                claude_content.append({
+                                    "type": "image",
+                                    "source": {
+                                        "type": "base64",
+                                        "media_type": media_type,
+                                        "data": data
+                                    }
+                                })
+                        else:
+                            # URL image
+                            claude_content.append({
+                                "type": "image",
+                                "source": {
+                                    "type": "url",
+                                    "url": url
+                                }
+                            })
+                claude_msg["content"] = claude_content
+            messages.append(claude_msg)
+
+        elif role == "assistant":
+            # Convert assistant message
+            claude_msg = {"role": "assistant", "content": []}
+
+            # Handle text content
+            if isinstance(content, str) and content:
+                claude_msg["content"].append({"type": "text", "text": content})
+            elif isinstance(content, list):
+                for block in content:
+                    if block.get("type") == "text":
+                        claude_msg["content"].append({"type": "text", "text": block.get("text", "")})
+
+            # Handle tool_calls
+            tool_calls = msg.get("tool_calls", [])
+            for tc in tool_calls:
+                if tc.get("type") == "function":
+                    func = tc.get("function", {})
+                    try:
+                        arguments = json.loads(func.get("arguments", "{}"))
+                    except:
+                        arguments = {}
+                    claude_msg["content"].append({
+                        "type": "tool_use",
+                        "id": tc.get("id", ""),
+                        "name": func.get("name", ""),
+                        "input": arguments
+                    })
+
+            messages.append(claude_msg)
+
+        elif role == "tool":
+            # Convert tool result to Claude format
+            # OpenAI tool messages should be converted to user messages with tool_result
+            tool_call_id = msg.get("tool_call_id", "")
+            tool_content = content if isinstance(content, str) else json.dumps(content)
+
+            messages.append({
+                "role": "user",
+                "content": [{
+                    "type": "tool_result",
+                    "tool_use_id": tool_call_id,
+                    "content": tool_content
+                }]
+            })
+
+    # Set system message
+    if system_messages:
+        claude_body["system"] = "\n\n".join(system_messages)
+
+    claude_body["messages"] = messages
+
+    # Model - already validated in proxy_openclaw_request
+    model = body.get("model")
+    claude_body["model"] = normalize_model_name(model)
+
+    # Max tokens
+    max_tokens = body.get("max_tokens") or body.get("max_completion_tokens", 4096)
+    claude_body["max_tokens"] = max_tokens
+
+    # Temperature
+    if "temperature" in body:
+        claude_body["temperature"] = body["temperature"]
+
+    # Top P
+    if "top_p" in body:
+        claude_body["top_p"] = body["top_p"]
+
+    # Stop sequences
+    if "stop" in body:
+        stop = body["stop"]
+        if isinstance(stop, str):
+            claude_body["stop_sequences"] = [stop]
+        elif isinstance(stop, list):
+            claude_body["stop_sequences"] = stop
+
+    # Stream
+    if "stream" in body:
+        claude_body["stream"] = body["stream"]
+
+    # Tools
+    if "tools" in body:
+        claude_tools = []
+        for tool in body["tools"]:
+            if tool.get("type") == "function":
+                func = tool.get("function", {})
+                claude_tools.append({
+                    "name": func.get("name", ""),
+                    "description": func.get("description", ""),
+                    "input_schema": func.get("parameters", {})
+                })
+        if claude_tools:
+            claude_body["tools"] = claude_tools
+
+    # Tool choice
+    if "tool_choice" in body:
+        tc = body["tool_choice"]
+        if tc == "auto":
+            claude_body["tool_choice"] = {"type": "auto"}
+        elif tc == "required" or tc == "any":
+            claude_body["tool_choice"] = {"type": "any"}
+        elif tc == "none":
+            claude_body["tool_choice"] = {"type": "auto"}
+        elif isinstance(tc, dict) and tc.get("type") == "function":
+            func_name = tc.get("function", {}).get("name")
+            if func_name:
+                claude_body["tool_choice"] = {"type": "tool", "name": func_name}
+
+    return claude_body
+
+
+def convert_claude_to_openai_response(claude_resp: dict, model: str) -> dict:
+    """Convert Claude response to OpenAI chat completion format"""
+    message_id = claude_resp.get("id", "chatcmpl-" + str(int(time.time())))
+    created = int(time.time())
+
+    # Build message content
+    message = {"role": "assistant"}
+    content_parts = []
+    tool_calls = []
+
+    for block in claude_resp.get("content", []):
+        if block.get("type") == "text":
+            content_parts.append(block.get("text", ""))
+        elif block.get("type") == "tool_use":
+            tool_calls.append({
+                "id": block.get("id", ""),
+                "type": "function",
+                "function": {
+                    "name": block.get("name", ""),
+                    "arguments": json.dumps(block.get("input", {}))
+                }
+            })
+
+    if content_parts:
+        message["content"] = "".join(content_parts)
+    else:
+        message["content"] = None
+
+    if tool_calls:
+        message["tool_calls"] = tool_calls
+
+    # Map stop_reason to finish_reason
+    stop_reason = claude_resp.get("stop_reason", "")
+    finish_reason_map = {
+        "end_turn": "stop",
+        "max_tokens": "length",
+        "stop_sequence": "stop",
+        "tool_use": "tool_calls"
+    }
+    finish_reason = finish_reason_map.get(stop_reason, "stop")
+
+    # Usage
+    usage_data = claude_resp.get("usage", {})
+    usage = {
+        "prompt_tokens": usage_data.get("input_tokens", 0),
+        "completion_tokens": usage_data.get("output_tokens", 0),
+        "total_tokens": usage_data.get("input_tokens", 0) + usage_data.get("output_tokens", 0)
+    }
+
+    return {
+        "id": message_id,
+        "object": "chat.completion",
+        "created": created,
+        "model": model,
+        "choices": [{
+            "index": 0,
+            "message": message,
+            "finish_reason": finish_reason
+        }],
+        "usage": usage
+    }
+
+
+async def handle_stream_response_as_openai(stream_url: str, model: str, api_key: str = None, is_gpt: bool = False) -> StreamingResponse:
+    """Convert Claude/Codex SSE stream to OpenAI SSE format"""
+
+    async def generate_openai_stream() -> AsyncGenerator[str, None]:
+        message_id = f"chatcmpl-{int(time.time())}"
+        created = int(time.time())
+
+        # State tracking (only needed for Claude responses)
+        content_block_types = {}  # index -> type
+        tool_call_index = -1
+        role_sent = False
+
+        try:
+            # Add agent_id parameter to URL (required by openclaw.aid.pub/responses.aid.pub)
+            current_agent = claude_proxy_async.get_current_agent_id()
+            if current_agent:
+                separator = "&" if "?" in stream_url else "?"
+                full_url = f"{stream_url}{separator}agent_id={current_agent.id}"
+            else:
+                full_url = stream_url
+
+            decoded_url = unquote(full_url)
+            logger.info(f"[Stream] Connecting to: {decoded_url}")
+            logger.info(f"[Stream] Is GPT model: {is_gpt}")
+
+            # Build headers with API key if provided
+            headers = {}
+            if api_key:
+                headers["Authorization"] = f"Bearer {api_key}"
+                headers["x-api-key"] = api_key
+
+            async with httpx.AsyncClient(verify=False, timeout=httpx.Timeout(30.0, read=300.0)) as client:
+                async with client.stream("GET", decoded_url, headers=headers) as response:
+                    logger.info(f"[Stream] Response status: {response.status_code}")
+
+                    if response.status_code != 200:
+                        error_text = await response.aread()
+                        error_msg = error_text.decode('utf-8') if error_text else "Stream request failed"
+                        logger.error(f"[Stream] Error response: {error_msg}")
+                        yield f'data: {json.dumps({"error": {"message": error_msg, "type": "api_error"}})}\n\n'
+                        return
+
+                    # For GPT models, convert responses-style stream to OpenAI chat-completions stream
+                    if is_gpt:
+                        response_id = None
+                        response_created = created
+                        role_sent = False
+                        tool_call_indices: Dict[str, int] = {}
+                        tool_call_names: Dict[str, str] = {}
+                        tool_call_arguments: Dict[str, str] = {}
+                        next_tool_call_index = 0
+
+                        def _emit_role_chunk() -> str:
+                            nonlocal role_sent
+                            if role_sent:
+                                return ""
+                            role_sent = True
+                            chunk = {
+                                "id": response_id or message_id,
+                                "object": "chat.completion.chunk",
+                                "created": response_created,
+                                "model": model,
+                                "choices": [{
+                                    "index": 0,
+                                    "delta": {"role": "assistant", "content": ""},
+                                    "finish_reason": None
+                                }]
+                            }
+                            return f"data: {json.dumps(chunk)}\n\n"
+
+                        def _emit_text_chunk(text: str) -> str:
+                            chunk = {
+                                "id": response_id or message_id,
+                                "object": "chat.completion.chunk",
+                                "created": response_created,
+                                "model": model,
+                                "choices": [{
+                                    "index": 0,
+                                    "delta": {"content": text},
+                                    "finish_reason": None
+                                }]
+                            }
+                            return f"data: {json.dumps(chunk)}\n\n"
+
+                        def _emit_tool_start(call_id: str, name: str, arguments: str = "") -> str:
+                            nonlocal next_tool_call_index
+                            if call_id not in tool_call_indices:
+                                tool_call_indices[call_id] = next_tool_call_index
+                                next_tool_call_index += 1
+                            index = tool_call_indices[call_id]
+                            safe_name = name or tool_call_names.get(call_id, "")
+                            safe_arguments = arguments or tool_call_arguments.get(call_id, "")
+                            tool_call_names[call_id] = safe_name
+                            tool_call_arguments[call_id] = safe_arguments
+                            chunk = {
+                                "id": response_id or message_id,
+                                "object": "chat.completion.chunk",
+                                "created": response_created,
+                                "model": model,
+                                "choices": [{
+                                    "index": 0,
+                                    "delta": {
+                                            "tool_calls": [{
+                                            "index": index,
+                                            "id": call_id,
+                                            "type": "function",
+                                            "function": {"name": safe_name, "arguments": safe_arguments}
+                                        }]
+                                    },
+                                    "finish_reason": None
+                                }]
+                            }
+                            return f"data: {json.dumps(chunk)}\n\n"
+
+                        def _emit_tool_args_delta(call_id: str, arguments_delta: str) -> str:
+                            nonlocal next_tool_call_index
+                            if call_id not in tool_call_indices:
+                                tool_call_indices[call_id] = next_tool_call_index
+                                next_tool_call_index += 1
+                            index = tool_call_indices[call_id]
+                            previous = tool_call_arguments.get(call_id, "")
+                            merged = previous + arguments_delta
+                            tool_call_arguments[call_id] = merged
+                            chunk = {
+                                "id": response_id or message_id,
+                                "object": "chat.completion.chunk",
+                                "created": response_created,
+                                "model": model,
+                                "choices": [{
+                                    "index": 0,
+                                    "delta": {
+                                        "tool_calls": [{
+                                            "index": index,
+                                            "function": {"arguments": arguments_delta}
+                                        }]
+                                    },
+                                    "finish_reason": None
+                                }]
+                            }
+                            return f"data: {json.dumps(chunk)}\n\n"
+
+                        def _normalize_arguments(value: Any) -> str:
+                            if isinstance(value, str):
+                                return value
+                            if isinstance(value, (dict, list)):
+                                return json.dumps(value, ensure_ascii=False)
+                            if value is None:
+                                return ""
+                            return str(value)
+
+                        def _emit_finish_chunk(reason: str, usage_data: dict = None) -> str:
+                            chunk = {
+                                "id": response_id or message_id,
+                                "object": "chat.completion.chunk",
+                                "created": response_created,
+                                "model": model,
+                                "choices": [{
+                                    "index": 0,
+                                    "delta": {},
+                                    "finish_reason": reason
+                                }]
+                            }
+                            if usage_data:
+                                prompt_tokens = usage_data.get("prompt_tokens", usage_data.get("input_tokens", 0))
+                                completion_tokens = usage_data.get("completion_tokens", usage_data.get("output_tokens", 0))
+                                chunk["usage"] = {
+                                    "prompt_tokens": prompt_tokens,
+                                    "completion_tokens": completion_tokens,
+                                    "total_tokens": usage_data.get("total_tokens", prompt_tokens + completion_tokens)
+                                }
+                            return f"data: {json.dumps(chunk)}\n\n"
+
+                        async for line in response.aiter_lines():
+                            if not line:
+                                continue
+
+                            try:
+                                # URL decode the line
+                                from urllib.parse import unquote_plus
+                                decoded_line = unquote_plus(line)
+
+                                # Skip comments
+                                if decoded_line.startswith(":"):
+                                    continue
+
+                                # Parse key:value format
+                                if ":" not in decoded_line:
+                                    continue
+
+                                key, value = decoded_line.split(":", 1)
+                                key = key.strip()
+                                value = value.strip()
+
+                                # Handle "data: event: xxx" or "data: data: {...}"
+                                if key == "data":
+                                    if ":" in value:
+                                        inner_key, inner_value = value.split(":", 1)
+                                        inner_key = inner_key.strip()
+                                        inner_value = inner_value.strip()
+
+                                        if inner_key == "data":
+                                            try:
+                                                event = json.loads(inner_value)
+                                            except Exception:
+                                                if inner_value == "[DONE]":
+                                                    if role_sent:
+                                                        yield _emit_finish_chunk("stop")
+                                                    yield "data: [DONE]\n\n"
+                                                    return
+                                                continue
+
+                                            # Upstream may already send OpenAI chat chunks.
+                                            if isinstance(event, dict) and "choices" in event:
+                                                yield f"data: {json.dumps(event)}\n\n"
+                                                continue
+
+                                            event_type = event.get("type")
+                                            if event_type == "response.created":
+                                                response_info = event.get("response", {})
+                                                response_id = response_info.get("id", response_id or message_id)
+                                                response_created = _to_unix_seconds(
+                                                    response_info.get("created_at"),
+                                                    response_created
+                                                )
+                                            elif event_type in ("response.output_text.delta", "response.output_text.annotation.added"):
+                                                role_chunk = _emit_role_chunk()
+                                                if role_chunk:
+                                                    yield role_chunk
+                                                delta = event.get("delta", "")
+                                                if delta:
+                                                    yield _emit_text_chunk(delta)
+                                            elif event_type == "response.output_item.added":
+                                                item = event.get("item", {})
+                                                if item.get("type") in ("function_call", "tool_call"):
+                                                    role_chunk = _emit_role_chunk()
+                                                    if role_chunk:
+                                                        yield role_chunk
+                                                    call_id = item.get("call_id", item.get("id", "")) or f"call_{next_tool_call_index}"
+                                                    name = item.get("name", "")
+                                                    arguments_value = item.get("arguments", item.get("arguments_json", item.get("input", "")))
+                                                    arguments_text = _normalize_arguments(arguments_value)
+                                                    tool_call_names[call_id] = name or tool_call_names.get(call_id, "")
+                                                    if arguments_text:
+                                                        tool_call_arguments[call_id] = arguments_text
+                                                    yield _emit_tool_start(
+                                                        call_id=call_id,
+                                                        name=name,
+                                                        arguments=arguments_text
+                                                    )
+                                            elif event_type in ("response.function_call_arguments.delta", "response.output_item.delta"):
+                                                role_chunk = _emit_role_chunk()
+                                                if role_chunk:
+                                                    yield role_chunk
+                                                call_id = event.get("call_id")
+                                                if not call_id and isinstance(event.get("item"), dict):
+                                                    call_id = event["item"].get("call_id", event["item"].get("id", ""))
+                                                if not call_id:
+                                                    continue
+                                                delta = event.get("delta", "")
+                                                if isinstance(delta, dict):
+                                                    delta = (
+                                                        delta.get("arguments")
+                                                        or delta.get("arguments_delta")
+                                                        or delta.get("partial_json")
+                                                        or ""
+                                                    )
+                                                if delta:
+                                                    yield _emit_tool_args_delta(call_id, str(delta))
+                                            elif event_type in ("response.function_call_arguments.done", "response.output_item.done"):
+                                                item = event.get("item", {})
+                                                call_id = event.get("call_id")
+                                                if not call_id and isinstance(item, dict):
+                                                    call_id = item.get("call_id", item.get("id", ""))
+                                                if not call_id:
+                                                    continue
+                                                full_args = _normalize_arguments(
+                                                    event.get("arguments")
+                                                    or (item.get("arguments") if isinstance(item, dict) else None)
+                                                    or (item.get("arguments_json") if isinstance(item, dict) else None)
+                                                    or (item.get("input") if isinstance(item, dict) else None)
+                                                )
+                                                if full_args:
+                                                    previous = tool_call_arguments.get(call_id, "")
+                                                    if not previous:
+                                                        # If we never got deltas, emit once so client receives arguments.
+                                                        yield _emit_tool_args_delta(call_id, full_args)
+                                                    elif full_args != previous and full_args.startswith(previous):
+                                                        # Emit missing suffix if done payload is more complete.
+                                                        suffix = full_args[len(previous):]
+                                                        if suffix:
+                                                            yield _emit_tool_args_delta(call_id, suffix)
+                                                    elif full_args != previous:
+                                                        # Fallback: replace mismatch by sending full args once more.
+                                                        yield _emit_tool_args_delta(call_id, full_args)
+                                            elif event_type == "response.completed":
+                                                response_info = event.get("response", {})
+                                                status = response_info.get("status", "completed")
+                                                usage_data = response_info.get("usage", {})
+                                                finish_reason = "stop"
+                                                if status in ("incomplete", "failed", "cancelled"):
+                                                    finish_reason = "length"
+                                                elif tool_call_indices:
+                                                    finish_reason = "tool_calls"
+                                                yield _emit_finish_chunk(finish_reason, usage_data)
+                                                yield "data: [DONE]\n\n"
+                                                return
+                                            elif event_type == "response.error":
+                                                error_info = event.get("error", {})
+                                                error_message = error_info.get("message", "Response stream error")
+                                                yield f'data: {json.dumps({"error": {"message": error_message, "type": "api_error"}})}\n\n'
+                                                yield "data: [DONE]\n\n"
+                                                return
+
+                                elif key == "event":
+                                    # Handle "event: done"
+                                    if value == "done":
+                                        if role_sent:
+                                            yield _emit_finish_chunk("stop")
+                                        yield "data: [DONE]\n\n"
+                                        return
+
+                            except Exception as e:
+                                logger.warning(f"Failed to process SSE line (GPT): {e}")
+                                continue
+
+                    else:
+                        # Process URL-encoded SSE stream from openclaw.aid.pub (Claude format)
+                        # Format: "data: event: xxx" and "data: data: {...}"
+                        current_event = None
+
+                        async for line in response.aiter_lines():
+                            if not line:
+                                continue
+
+                            try:
+                                # URL decode the line (openclaw.aid.pub uses URL encoding)
+                                from urllib.parse import unquote_plus
+                                decoded_line = unquote_plus(line)
+
+                                # Skip comments
+                                if decoded_line.startswith(":"):
+                                    continue
+
+                                # Parse key:value format
+                                if ":" not in decoded_line:
+                                    continue
+
+                                key, value = decoded_line.split(":", 1)
+                                key = key.strip()
+                                value = value.strip()
+
+                                # Handle "data: event: xxx" or "data: data: {...}"
+                                if key == "data":
+                                    if ":" in value:
+                                        inner_key, inner_value = value.split(":", 1)
+                                        inner_key = inner_key.strip()
+                                        inner_value = inner_value.strip()
+
+                                    if inner_key == "event":
+                                        # Cache event type
+                                        current_event = inner_value
+                                    elif inner_key == "data":
+                                        # Got data line, process the Claude event
+                                        if current_event:
+                                            try:
+                                                event = json.loads(inner_value)
+                                                event_type = event.get("type")
+
+                                                if event_type == "message_start":
+                                                    # Send role
+                                                    chunk = {
+                                                        "id": message_id,
+                                                        "object": "chat.completion.chunk",
+                                                        "created": created,
+                                                        "model": model,
+                                                        "choices": [{
+                                                            "index": 0,
+                                                            "delta": {"role": "assistant", "content": ""},
+                                                            "finish_reason": None
+                                                        }]
+                                                    }
+                                                    yield f"data: {json.dumps(chunk)}\n\n"
+                                                    role_sent = True
+
+                                                elif event_type == "content_block_start":
+                                                    block_index = event.get("index", 0)
+                                                    content_block = event.get("content_block", {})
+                                                    block_type = content_block.get("type")
+                                                    content_block_types[block_index] = block_type
+
+                                                    if block_type == "tool_use":
+                                                        tool_call_index += 1
+                                                        chunk = {
+                                                            "id": message_id,
+                                                            "object": "chat.completion.chunk",
+                                                            "created": created,
+                                                            "model": model,
+                                                            "choices": [{
+                                                                "index": 0,
+                                                                "delta": {
+                                                                    "tool_calls": [{
+                                                                        "index": tool_call_index,
+                                                                        "id": content_block.get("id", ""),
+                                                                        "type": "function",
+                                                                        "function": {
+                                                                            "name": content_block.get("name", ""),
+                                                                            "arguments": ""
+                                                                        }
+                                                                    }]
+                                                                },
+                                                                "finish_reason": None
+                                                            }]
+                                                        }
+                                                        yield f"data: {json.dumps(chunk)}\n\n"
+
+                                                elif event_type == "content_block_delta":
+                                                    delta = event.get("delta", {})
+                                                    delta_type = delta.get("type")
+
+                                                    if delta_type == "text_delta":
+                                                        text = delta.get("text", "")
+                                                        chunk = {
+                                                            "id": message_id,
+                                                            "object": "chat.completion.chunk",
+                                                            "created": created,
+                                                            "model": model,
+                                                            "choices": [{
+                                                                "index": 0,
+                                                                "delta": {"content": text},
+                                                                "finish_reason": None
+                                                            }]
+                                                        }
+                                                        yield f"data: {json.dumps(chunk)}\n\n"
+
+                                                    elif delta_type == "input_json_delta":
+                                                        partial_json = delta.get("partial_json", "")
+                                                        chunk = {
+                                                            "id": message_id,
+                                                            "object": "chat.completion.chunk",
+                                                            "created": created,
+                                                            "model": model,
+                                                            "choices": [{
+                                                                "index": 0,
+                                                                "delta": {
+                                                                    "tool_calls": [{
+                                                                        "index": tool_call_index,
+                                                                        "function": {
+                                                                            "arguments": partial_json
+                                                                        }
+                                                                    }]
+                                                                },
+                                                                "finish_reason": None
+                                                            }]
+                                                        }
+                                                        yield f"data: {json.dumps(chunk)}\n\n"
+
+                                                elif event_type == "message_delta":
+                                                    # Send finish_reason and usage
+                                                    stop_reason = event.get("delta", {}).get("stop_reason", "")
+                                                    finish_reason_map = {
+                                                        "end_turn": "stop",
+                                                        "max_tokens": "length",
+                                                        "stop_sequence": "stop",
+                                                        "tool_use": "tool_calls"
+                                                    }
+                                                    finish_reason = finish_reason_map.get(stop_reason, "stop")
+
+                                                    usage_data = event.get("usage", {})
+                                                    chunk = {
+                                                        "id": message_id,
+                                                        "object": "chat.completion.chunk",
+                                                        "created": created,
+                                                        "model": model,
+                                                        "choices": [{
+                                                            "index": 0,
+                                                            "delta": {},
+                                                            "finish_reason": finish_reason
+                                                        }],
+                                                        "usage": {
+                                                            "prompt_tokens": usage_data.get("input_tokens", 0),
+                                                            "completion_tokens": usage_data.get("output_tokens", 0),
+                                                            "total_tokens": usage_data.get("input_tokens", 0) + usage_data.get("output_tokens", 0)
+                                                        }
+                                                    }
+                                                    yield f"data: {json.dumps(chunk)}\n\n"
+
+                                                elif event_type == "message_stop":
+                                                    yield "data: [DONE]\n\n"
+
+                                                elif event_type == "ping":
+                                                    pass  # Ignore ping events
+
+                                            except json.JSONDecodeError:
+                                                logger.warning(f"Failed to parse SSE data: {inner_value[:100]}")
+                                            current_event = None
+
+                                elif key == "event":
+                                    # Handle "event: done"
+                                    if value == "done":
+                                        yield "data: [DONE]\n\n"
+                                        return
+
+                            except Exception as e:
+                                logger.warning(f"Failed to process SSE line: {e}")
+                                continue
+
+        except Exception as e:
+            logger.error(f"Stream error: {e}")
+            yield f'data: {json.dumps({"error": {"message": str(e), "type": "api_error"}})}\n\n'
+
+    return StreamingResponse(generate_openai_stream(), media_type="text/event-stream")
+
+
+def get_openclaw_proxy_config():
+    """获取 OpenClaw 代理配置"""
+    from .proxy_config import ProxyConfig
+
+    return ProxyConfig(
+        target_aid_getter=lambda api_key: "openclaw.aid.pub",
+        request_converter=convert_openai_to_claude_request,
+        response_converter=lambda resp: convert_claude_to_openai_response(resp, resp.get("model", "gpt-4o")) if isinstance(resp, dict) and "content" in resp else resp,
+        stream_handler=lambda url: handle_stream_response_as_openai(url, "gpt-4o", None, True),
+        error_formatter=lambda e: openai_error_response(str(e), "api_error", status_code=500),
+        model_validator=is_model_supported,
+        proxy_type="openclaw"
+    )
+
+
+async def proxy_openclaw_request(request: Request) -> Response:
+    """Main proxy handler for OpenClaw requests - 使用统一引擎"""
+    # Note: OpenClaw has complex session management with target_aid
+    # For now, keep using legacy implementation
+    # TODO: Fully integrate with proxy_engine after testing
+    return await proxy_openclaw_request_legacy(request)
+
+
+async def proxy_openclaw_request_legacy(request: Request) -> Response:
+    """Main proxy handler for OpenClaw requests - 原始实现（备份）"""
+
+    logger.debug(f"[OpenClaw] proxy_openclaw_request called")
+    shared_agent_id = claude_proxy_async.get_current_agent_id()
+    logger.debug(f"[OpenClaw] shared agent_id is None: {shared_agent_id is None}")
+
+    # Check if AgentCP is ready (shared with claude proxy)
+    if not shared_agent_id:
+        logger.error("[OpenClaw] AgentID not initialized - returning error")
+        return openai_error_response(
+            "AgentCP not initialized. Please ensure the agent is connected.",
+            error_type="service_unavailable",
+            status_code=503
+        )
+
+    # Parse request body
+    logger.debug("[OpenClaw] Parsing request body...")
+    try:
+        body = await request.json()
+        logger.debug(f"[OpenClaw] Body parsed, model: {body.get('model', 'N/A')}")
+    except Exception as e:
+        logger.error(f"[OpenClaw] JSON parse error: {e}")
+        return openai_error_response(f"Invalid JSON: {str(e)}")
+
+    # Get model
+    model = body.get("model", "")
+    logger.debug(f"[OpenClaw] Model: {model}")
+    if not model:
+        return openai_error_response("Missing required parameter: model")
+
+    # Check if model is supported
+    logger.debug(f"[OpenClaw] Checking if model is supported: {model}")
+    if not is_model_supported(model):
+        logger.debug(f"[OpenClaw] Model not supported: {model}")
+        return openai_error_response(
+            f"Model not supported: {model}",
+            error_type="invalid_request_error"
+        )
+        logger.debug(f"[OpenClaw] Model is supported")
+
+    # Get API key from header - this is the user's API key (evol-xxx format)
+    # It will be used as both the user key and Claude API key (transparent pass-through)
+    logger.debug("[OpenClaw] Getting API key from header...")
+    auth_header = request.headers.get("authorization", "")
+    if not auth_header.startswith("Bearer "):
+        logger.debug("[OpenClaw] Missing or invalid authorization header")
+        return openai_error_response("Missing or invalid authorization header", status_code=401)
+
+    user_api_key = auth_header[7:]  # Extract the API key (e.g., evol-xxx)
+    logger.debug(f"[OpenClaw] API key extracted: {user_api_key[:10]}...")
+
+    # Determine if this is a GPT/Codex model or Claude model
+    # Also check the request path - /codex-proxy/ indicates GPT model
+    request_path = str(request.url.path)
+    is_codex_path = "/codex-proxy/" in request_path
+    is_gpt = is_gpt_model(model) or is_codex_path
+    logger.debug(f"[OpenClaw] is_gpt: {is_gpt}, request_path: {request_path}")
+
+    # Convert OpenAI request to appropriate format
+    logger.debug("[OpenClaw] Converting request format...")
+    try:
+        if is_gpt:
+            # Convert to responses format payload
+            request_body = convert_openai_to_response_format(body)
+            logger.debug(f"[OpenClaw] Converted to GPT/Codex format, model: {request_body.get('model')}")
+        else:
+            # Convert to Claude format
+            request_body = convert_openai_to_claude_request(body)
+            logger.debug(f"[OpenClaw] Converted to Claude format, model: {request_body.get('model')}")
+    except Exception as e:
+        logger.error(f"[OpenClaw] Request conversion error: {e}")
+        return openai_error_response(f"Request conversion failed: {str(e)}")
+
+    # Build proxy message with complete headers (same format as claude-proxy)
+    trace_id = f"openclaw-{int(time.time() * 1000)}"
+    logger.debug(f"[OpenClaw] trace_id: {trace_id}")
+
+    # Construct headers following the reference format
+    # The user's API key is transparently passed through as both authorization and x-api-key
+    proxy_headers = {
+        "connection": "keep-alive",
+        "accept": "application/json",
+        "x-stainless-retry-count": "0",
+        "x-stainless-timeout": "600",
+        "x-stainless-lang": "js",
+        "x-stainless-package-version": "0.74.0",
+        "x-stainless-os": "Windows",
+        "x-stainless-arch": "x64",
+        "x-stainless-runtime": "node",
+        "x-stainless-runtime-version": "v22.20.0",
+        "anthropic-dangerous-direct-browser-access": "true",
+        "anthropic-version": "2023-06-01",
+        "x-app": "cli",
+        "user-agent": "claude-cli/2.1.63 (external, openclaw-proxy, evol-electron-app)",
+        "authorization": f"Bearer {user_api_key}",  # User's API key (lowercase)
+        "content-type": "application/json",
+        "anthropic-beta": "claude-code-20250219,interleaved-thinking-2025-05-14,prompt-caching-scope-2026-01-05,effort-2025-11-24,adaptive-thinking-2026-01-28",
+        "accept-language": "*",
+        "accept-encoding": "gzip, deflate",
+        "Authorization": f"Bearer {user_api_key}",  # Same key (uppercase for compatibility)
+        "x-api-key": user_api_key  # Same key for x-api-key header
+    }
+
+    # Determine the API path based on model type
+    # For GPT models, use responses endpoint (without /v1 prefix)
+    if is_gpt:
+        # GPT models use responses endpoint
+        api_path = "/responses"
+    else:
+        # Claude uses /v1/messages
+        api_path = "/v1/messages"
+
+        logger.debug(f"[OpenClaw] API path: {api_path}, Is GPT: {is_gpt}")
+
+    # Build proxy message - all requests go to openclaw.aid.pub
+    # Use different type for GPT vs Claude so openclaw.aid.pub can route correctly
+    proxy_message = {
+        "type": "codex_proxy" if is_gpt else "claude_proxy",
+        "status": "success",
+        "timestamp": int(time.time() * 1000),
+        "trace_id": trace_id,
+        "content": {
+            "path": api_path,
+            "method": "POST",
+            "headers": proxy_headers,
+            "body": request_body,  # Contains responses-style payload for GPT or Claude messages format
+            "source": "evol",
+            "version": "1.0.0"
+        }
+    }
+    logger.debug(f"[OpenClaw] Proxy message built, type: {proxy_message['type']}")
+
+    # Send to AgentCP using shared claude-proxy session manager
+    async_session_manager = None
+    try:
+        # Shared manager debug
+        logger.debug(f"[OpenClaw] openclaw_agentId(legacy): {openclaw_agentId.id if openclaw_agentId else 'None'}")
+        logger.debug(f"[OpenClaw] shared_agent_id: {shared_agent_id.id if shared_agent_id else 'None'}")
+        async_session_manager = await claude_proxy_async.get_async_session_manager(shared_agent_id)
+        logger.debug(f"[OpenClaw] shared_session_manager: {async_session_manager}")
+
+        # Register response event
+        logger.debug(f"[OpenClaw] Registering response event for trace_id: {trace_id}")
+        response_event = asyncio.Event()
+        async_session_manager._pending_requests[trace_id] = response_event
+        async_session_manager.register_request_timestamp(trace_id)
+        logger.debug(f"[OpenClaw] Response event registered")
+
+        # Get session and send message
+        logger.debug(f"[OpenClaw] Getting session...")
+        agent_name = "openclaw.aid.pub"
+        session_scope_key = f"{agent_name}:{user_api_key}"
+        session_id = await async_session_manager.get_session(
+            user_api_key,
+            shared_agent_id,
+            target_aid=agent_name,
+            session_name="openclaw_proxy",
+            session_subject="openclaw_proxy",
+            session_scope_key=session_scope_key,
+        )
+        if not session_id:
+            logger.debug(f"[OpenClaw] Failed to get session")
+            return openai_error_response("Failed to get AgentCP session", error_type="api_error", status_code=503)
+            logger.debug(f"[OpenClaw] Got session_id: {session_id}")
+        try:
+            session_data = async_session_manager._session_info.get(session_id, {})
+            session_target = session_data.get("target_aid")
+            session_key = session_data.get("session_key")
+            session_last_used = session_data.get("last_used")
+            now_ts = time.time()
+            idle_seconds = (now_ts - session_last_used) if isinstance(session_last_used, (int, float)) else None
+            logger.debug(
+ f"[OpenClawDiag] Session detail: session_id={session_id}, "
+ f"target_aid={session_target}, session_key={session_key}, "
+ f"idle_seconds={idle_seconds:.2f}" if idle_seconds is not None else
+ f"[OpenClawDiag] Session detail: session_id={session_id}, "
+ f"target_aid={session_target}, session_key={session_key}, idle_seconds=None"
+ )
+        except Exception as inspect_err:
+            logger.debug(f"[OpenClawDiag] Session detail inspect failed: {inspect_err}")
+            logger.debug(
+ f"[OpenClaw] Session state: handler_registered={session_id in async_session_manager._handler_registered}, "
+ f"pending_count={len(async_session_manager._pending_requests)}"
+ )
+
+        # All requests go to openclaw.aid.pub
+        logger.debug(f"[OpenClaw] Sending message to {agent_name}...")
+
+        # ===== 发送前诊断：检查 SDK 内部状态 =====
+        try:
+            # 1. 检查 session_manager 中是否存在该 session
+            sm = getattr(shared_agent_id, 'session_manager', None)
+            sm_sessions = getattr(sm, 'sessions', {}) if sm else {}
+            session_exists_in_sm = session_id in sm_sessions
+            sm_session_count = len(sm_sessions)
+
+            # 2. 检查 message_client_map
+            mc_map = getattr(sm, 'message_client_map', {}) if sm else {}
+            mc_count = len(mc_map)
+
+            # 3. 检查 handler 注册状态
+            handler_map = getattr(shared_agent_id, 'message_handlers_session_map', {})
+            handler_bound = session_id in handler_map
+            handler_map_size = len(handler_map)
+            global_handlers_count = len(getattr(shared_agent_id, 'message_handlers', []))
+
+            # 4. 检查 WebSocket 连接状态
+            ws_status = "unknown"
+            mc_connection_id = "unknown"
+            if sm and sm_sessions.get(session_id):
+                sess_obj = sm_sessions[session_id]
+                mc = getattr(sess_obj, 'message_client', None)
+                if mc:
+                    ws_status = f"ws_open={mc._is_ws_open()}, state={getattr(mc, '_connection_state', 'N/A')}"
+                    mc_connection_id = getattr(mc, '_connection_id', 'N/A')
+            elif mc_map:
+                # session 可能还不在 sessions 中，检查 message_client_map
+                for url, mc in mc_map.items():
+                    ws_status = f"ws_open={mc._is_ws_open()}, state={getattr(mc, '_connection_state', 'N/A')}"
+                    mc_connection_id = getattr(mc, '_connection_id', 'N/A')
+                    break
+
+                    logger.debug(
+ f"[OpenClawDiag] PRE-SEND: session_exists_in_sm={session_exists_in_sm}, "
+ f"sm_session_count={sm_session_count}, mc_count={mc_count}, "
+ f"handler_bound={handler_bound}, handler_map_size={handler_map_size}, "
+ f"global_handlers={global_handlers_count}, "
+ f"ws={ws_status}, mc_conn_id={mc_connection_id}"
+ )
+        except Exception as diag_err:
+            logger.debug(f"[OpenClawDiag] PRE-SEND inspect failed: {diag_err}")
+
+        send_result = await asyncio.to_thread(
+            shared_agent_id.send_message, session_id, [agent_name], proxy_message
+        )
+
+        # ===== 发送后诊断 =====
+        try:
+            # 重新检查 session 是否被新建
+            sm = getattr(shared_agent_id, 'session_manager', None)
+            sm_sessions = getattr(sm, 'sessions', {}) if sm else {}
+            session_exists_after = session_id in sm_sessions
+
+            # 检查 handler 是否仍然绑定
+            handler_map = getattr(shared_agent_id, 'message_handlers_session_map', {})
+            handler_bound_after = session_id in handler_map
+
+            logger.debug(
+ f"[OpenClawDiag] POST-SEND: send_result={send_result}, "
+ f"session_exists_after={session_exists_after}, "
+ f"handler_bound_after={handler_bound_after}, "
+ f"handler_map_keys={list(handler_map.keys())[:5]}"
+ )
+        except Exception as diag_err:
+            logger.debug(f"[OpenClawDiag] POST-SEND inspect failed: {diag_err}")
+
+            logger.debug(
+ f"[OpenClawDiag] send_message done: session_id={session_id}, target={agent_name}, "
+ f"trace_id={trace_id}"
+ )
+
+        # Wait for response (300s timeout) - 带早期诊断轮询
+        try:
+            # 前10秒每2秒检查一次状态，帮助诊断消息是否到达
+            for _poll_i in range(5):
+                try:
+                    await asyncio.wait_for(response_event.wait(), timeout=2)
+                    logger.debug(f"[OpenClaw] Response received (within {(_poll_i+1)*2}s)")
+                    break
+                except asyncio.TimeoutError:
+                    # 还没收到，打印诊断
+                    try:
+                        sm = getattr(shared_agent_id, 'session_manager', None)
+                        sm_sessions = getattr(sm, 'sessions', {}) if sm else {}
+                        handler_map = getattr(shared_agent_id, 'message_handlers_session_map', {})
+                        # 检查 dispatch queue 状态
+                        dq = getattr(shared_agent_id, 'message_dispatch_queue', None)
+                        dq_size = dq.qsize() if dq else -1
+                        # 检查 metrics
+                        metrics = getattr(shared_agent_id, 'metrics', None)
+                        received = getattr(metrics, 'received_total', -1) if metrics else -1
+                        dispatched = getattr(metrics, 'dispatched_total', -1) if metrics else -1
+                        logger.debug(
+ f"[OpenClawDiag] POLL {(_poll_i+1)*2}s: event_set={response_event.is_set()}, "
+ f"result_exists={trace_id in async_session_manager._request_result_map}, "
+ f"dispatch_queue_size={dq_size}, "
+ f"sm_session_exists={session_id in sm_sessions}, "
+ f"handler_bound={session_id in handler_map}, "
+ f"metrics_received={received}, metrics_dispatched={dispatched}"
+ )
+                    except Exception as poll_err:
+                        logger.debug(f"[OpenClawDiag] POLL {(_poll_i+1)*2}s inspect failed: {poll_err}")
+                    continue
+            else:
+                # 前10秒没收到，切换到长等待
+                logger.debug(f"[OpenClawDiag] 10s内未收到响应，进入长等待 (剩余290s)...")
+                await asyncio.wait_for(response_event.wait(), timeout=290)
+                logger.debug(f"[OpenClaw] Response received (after >10s)")
+        except asyncio.TimeoutError:
+            pending_keys = list(async_session_manager._pending_requests.keys())
+            result_keys = list(async_session_manager._request_result_map.keys())
+            logger.debug(
+ f"[OpenClaw] Request timeout, trace_id={trace_id}, "
+ f"pending_count={len(pending_keys)}, result_count={len(result_keys)}"
+ )
+            # ===== Timeout 全面诊断 =====
+            try:
+                handler_map = getattr(shared_agent_id, "message_handlers_session_map", None)
+                if isinstance(handler_map, dict):
+                    logger.debug(
+ f"[OpenClaw] Timeout handler-map: map_size={len(handler_map)}, "
+ f"session_bound={session_id in handler_map}"
+ )
+                    if session_id in handler_map:
+                        try:
+                            handlers_for_session = handler_map.get(session_id, [])
+                            handlers_count = len(handlers_for_session) if hasattr(handlers_for_session, "__len__") else -1
+                            logger.debug(
+ f"[OpenClawDiag] Timeout handler detail: session_id={session_id}, "
+ f"handlers_count={handlers_count}"
+ )
+                        except Exception as h_err:
+                            logger.debug(f"[OpenClawDiag] Timeout handler detail inspect failed: {h_err}")
+            except Exception as inspect_err:
+                logger.debug(f"[OpenClaw] Timeout handler-map inspect failed: {inspect_err}")
+
+            # SDK 内部连接 + 线程状态
+            try:
+                sm = getattr(shared_agent_id, 'session_manager', None)
+                sm_sessions = getattr(sm, 'sessions', {}) if sm else {}
+                mc_map = getattr(sm, 'message_client_map', {}) if sm else {}
+
+                # WebSocket 连接状态
+                for url, mc in mc_map.items():
+                    ws_open = mc._is_ws_open()
+                    conn_state = getattr(mc, '_connection_state', 'N/A')
+                    conn_id = getattr(mc, '_connection_id', 'N/A')
+                    ws_thread = getattr(mc, 'ws_thread', None)
+                    ws_thread_alive = ws_thread.is_alive() if ws_thread else False
+                    pending_q = getattr(mc, '_pending_messages', None)
+                    pending_q_size = pending_q.qsize() if pending_q and hasattr(pending_q, 'qsize') else -1
+                    logger.debug(
+ f"[OpenClawDiag] Timeout MC[{url[:50]}]: ws_open={ws_open}, "
+ f"state={conn_state}, conn_id={conn_id}, "
+ f"ws_thread_alive={ws_thread_alive}, pending_q_size={pending_q_size}"
+ )
+
+                # Dispatcher 线程状态
+                dispatcher_thread = getattr(shared_agent_id, '_message_dispatcher_thread', None)
+                dispatcher_alive = dispatcher_thread.is_alive() if dispatcher_thread else False
+                dq = getattr(shared_agent_id, 'message_dispatch_queue', None)
+                dq_size = dq.qsize() if dq else -1
+                metrics = getattr(shared_agent_id, 'metrics', None)
+                received = getattr(metrics, 'received_total', -1) if metrics else -1
+                dispatched = getattr(metrics, 'dispatched_total', -1) if metrics else -1
+                dispatch_fail = getattr(metrics, 'dispatch_failures', -1) if metrics else -1
+
+                logger.debug(
+ f"[OpenClawDiag] Timeout dispatcher: alive={dispatcher_alive}, "
+ f"queue_size={dq_size}, received={received}, "
+ f"dispatched={dispatched}, dispatch_fail={dispatch_fail}"
+ )
+
+                # SM sessions 列表
+                sm_session_ids = list(sm_sessions.keys())[:10]
+                logger.debug(f"[OpenClawDiag] Timeout SM sessions: {sm_session_ids}")
+            except Exception as sdk_err:
+                logger.debug(f"[OpenClawDiag] Timeout SDK inspect failed: {sdk_err}")
+
+            openclaw_pending = [k for k in async_session_manager._pending_requests.keys() if str(k).startswith("openclaw-")]
+            openclaw_results = [k for k in async_session_manager._request_result_map.keys() if str(k).startswith("openclaw-")]
+            logger.debug(
+ f"[OpenClawDiag] Timeout openclaw maps: pending={len(openclaw_pending)}, "
+ f"results={len(openclaw_results)}, pending_sample={openclaw_pending[:10]}, "
+ f"results_sample={openclaw_results[:10]}"
+ )
+            return openai_error_response("Request timeout", error_type="timeout", status_code=504)
+
+        # Get result from result_map
+        logger.debug(f"[OpenClaw] Getting result from result_map...")
+        result_data = async_session_manager._request_result_map.get(trace_id)
+        logger.debug(
+ f"[OpenClawDiag] result_map lookup: trace_id={trace_id}, "
+ f"found={result_data is not None}, pending_has_trace={trace_id in async_session_manager._pending_requests}, "
+ f"result_has_trace={trace_id in async_session_manager._request_result_map}"
+ )
+        if not result_data:
+            logger.debug(f"[OpenClaw] No response received")
+            openclaw_results = [k for k in async_session_manager._request_result_map.keys() if str(k).startswith("openclaw-")]
+            logger.debug(
+ f"[OpenClawDiag] No response map status: trace_id={trace_id}, "
+ f"openclaw_result_count={len(openclaw_results)}, sample={openclaw_results[:10]}"
+ )
+            return openai_error_response("No response received", error_type="api_error", status_code=503)
+
+        result_type = result_data.get("result_type", "")
+        response_msg = result_data.get("result", {})
+
+        logger.debug(f"[OpenClaw] Result type: {result_type}")
+        logger.debug(f"[OpenClaw] Response message keys: {response_msg.keys() if isinstance(response_msg, dict) else 'not a dict'}")
+        logger.debug(f"[OpenClawDiag] Raw result_data: {result_data}")
+
+        # Handle error response
+        if result_type == "error":
+            error_message, http_status = normalize_openclaw_error_message(response_msg)
+
+            logger.error(f"[Proxy] Error response: {error_message}, status: {http_status}")
+            logger.error(
+ f"[OpenClawDiag] Returning error response: trace_id={trace_id}, "
+ f"message={error_message}, status={http_status}, raw_response_msg={response_msg}"
+ )
+            return openai_error_response(error_message, error_type="service_unavailable", status_code=http_status)
+
+            # Check if it's a service offline error and provide a user-friendly message
+            if "不在线" in error_message or "offline" in error_message.lower():
+                error_message = "模型服务维护中，请稍后重试"
+                http_status = 503
+
+            return openai_error_response(error_message, error_type="service_unavailable", status_code=http_status)
+
+        # Handle streaming response
+        if result_type == "text/event-stream":
+            content = response_msg.get("content", {}) if isinstance(response_msg, dict) else response_msg
+            stream_url = content if isinstance(content, str) else content.get("url", "")
+
+            logger.info(f"[Stream] Extracted stream URL: {stream_url}")
+            logger.info(f"[Stream] Response message: {response_msg}")
+
+            if stream_url:
+                return await handle_stream_response_as_openai(stream_url, model, user_api_key, is_gpt)
+            else:
+                return openai_error_response("Stream URL missing", error_type="api_error", status_code=500)
+
+        # Handle normal response
+        content = response_msg.get("content", {}) if isinstance(response_msg, dict) else response_msg
+        if isinstance(content, dict):
+            response_body = content.get("body", {})
+            if isinstance(response_body, str):
+                try:
+                    response_body = json.loads(response_body)
+                except:
+                    pass
+        else:
+            response_body = content
+
+        # For GPT models, convert responses format to OpenAI /v1/chat/completions format
+        if is_gpt:
+            try:
+                openai_response = convert_response_to_openai_format(response_body, model)
+                return JSONResponse(openai_response)
+            except Exception as e:
+                logger.error(f"Response conversion error (GPT): {e}")
+                return openai_error_response(f"Response conversion failed: {str(e)}", error_type="api_error", status_code=500)
+
+        # Convert Claude response to OpenAI format
+        try:
+            openai_response = convert_claude_to_openai_response(response_body, model)
+            return JSONResponse(openai_response)
+        except Exception as e:
+            logger.error(f"Response conversion error: {e}")
+            return openai_error_response(f"Response conversion failed: {str(e)}", error_type="api_error", status_code=500)
+
+    except Exception as e:
+        logger.error(f"Proxy error: {e}")
+        import traceback
+        logger.debug(traceback.format_exc())
+        return openai_error_response(f"Proxy error: {str(e)}", error_type="api_error", status_code=500)
+    finally:
+        # Cleanup
+        try:
+            if async_session_manager is not None:
+                async_session_manager._pending_requests.pop(trace_id, None)
+                async_session_manager._request_result_map.pop(trace_id, None)
+        except:
+            pass