Upload app.py

app.py

@@ -0,0 +1,549 @@
+"""
+Claude Web API Proxy - HuggingFace Spaces with ReAct
+"""
+from fastapi import FastAPI, Request
+from fastapi.responses import StreamingResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+import httpx
+import json
+import asyncio
+from datetime import datetime
+from typing import Optional, Dict
+import os
+import uuid
+import re
+import pickle
+from pathlib import Path
+import logging
+
+# 日志配置
+logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s')
+logger = logging.getLogger(__name__)
+
+# 重试函数
+async def retry_async(fn, max_retries=3, delay=1.0):
+    for i in range(max_retries):
+        try:
+            return await fn()
+        except Exception as e:
+            if i == max_retries - 1:
+                raise
+            logger.warning(f"Retry {i+1}/{max_retries}: {e}")
+            await asyncio.sleep(delay * (i + 1))
+
+# 文件持久化
+CACHE_FILE = Path("/tmp/conversation_cache.pkl")
+conversation_cache: Dict[str, str] = {}
+
+def load_cache():
+    global conversation_cache
+    if CACHE_FILE.exists():
+        try:
+            with open(CACHE_FILE, 'rb') as f:
+                conversation_cache = pickle.load(f)
+        except:
+            conversation_cache = {}
+
+def save_cache():
+    try:
+        with open(CACHE_FILE, 'wb') as f:
+            pickle.dump(conversation_cache, f)
+    except:
+        pass
+
+# 智能保活
+last_request_time = datetime.now()
+
+async def keep_alive():
+    while True:
+        idle_time = (datetime.now() - last_request_time).total_seconds()
+        if idle_time < 3600:
+            await asyncio.sleep(1800)
+        else:
+            await asyncio.sleep(6 * 3600)
+        try:
+            async with httpx.AsyncClient() as client:
+                url = os.getenv("SPACE_URL", "")
+                if url:
+                    await client.get(f"{url}/health")
+        except:
+            pass
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    load_cache()
+    logger.info("Application started")
+    yield
+    logger.info("Application shutdown")
+
+app = FastAPI(title="Claude Proxy", lifespan=lifespan)
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
+
+# 全局请求日志中间件
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    logger.info(f"[GLOBAL] {request.method} {request.url.path} from {request.client.host if request.client else 'unknown'}")
+    response = await call_next(request)
+    return response
+
+@app.get("/clear_cache")
+async def clear_cache():
+    global conversation_cache
+    conversation_cache = {}
+    if CACHE_FILE.exists():
+        CACHE_FILE.unlink()
+    return {"status": "cache cleared"}
+
+@app.get("/logs")
+async def get_logs():
+    """获取最近的日志"""
+    try:
+        # 读取日志（假设日志输出到标准输出）
+        import subprocess
+        result = subprocess.run(['tail', '-n', '100', '/proc/1/fd/1'], 
+                              capture_output=True, text=True, timeout=5)
+        return {"logs": result.stdout}
+    except:
+        return {"error": "Cannot read logs"}
+
+@app.get("/health")
+async def health():
+    return {"status": "ok", "time": datetime.now().isoformat()}
+
+@app.get("/")
+async def root():
+    return {"name": "Claude Proxy", "version": "2.0-hf-react"}
+
+async def get_org_id(key: str) -> Optional[str]:
+    logger.info("[3] Space → Claude REQUEST: GET /api/organizations")
+    headers = {
+        'Cookie': f'sessionKey={key[:20]}...',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        'Accept': 'application/json',
+        'Accept-Language': 'en-US,en;q=0.9',
+        'Referer': 'https://claude.ai/chats',
+        'Origin': 'https://claude.ai',
+        'Sec-Fetch-Dest': 'empty',
+        'Sec-Fetch-Mode': 'cors',
+        'Sec-Fetch-Site': 'same-origin'
+    }
+    async with httpx.AsyncClient() as client:
+        r = await client.get('https://claude.ai/api/organizations',
+            headers={**headers, 'Cookie': f'sessionKey={key}'}, timeout=30.0)
+        logger.info(f"[4] Claude → Space RESPONSE: status={r.status_code}, body={r.text[:200]}")
+        if r.status_code == 200:
+            data = r.json()
+            return data[0]['uuid'] if data else None
+        else:
+            raise Exception(f"Claude.ai returned {r.status_code}")
+
+async def create_conv(key: str, org_id: str) -> Optional[str]:
+    conv_id = str(uuid.uuid4())
+    headers = {
+        'Content-Type': 'application/json',
+        'Cookie': f'sessionKey={key}',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        'Accept': 'application/json',
+        'Accept-Language': 'en-US,en;q=0.9',
+        'Referer': 'https://claude.ai/chats',
+        'Origin': 'https://claude.ai',
+        'Sec-Fetch-Dest': 'empty',
+        'Sec-Fetch-Mode': 'cors',
+        'Sec-Fetch-Site': 'same-origin'
+    }
+    async with httpx.AsyncClient() as client:
+        r = await client.post(f'https://claude.ai/api/organizations/{org_id}/chat_conversations',
+            headers=headers,
+            json={
+                'uuid': conv_id, 
+                'name': '', 
+                'include_conversation_preferences': True,
+                'is_temporary': False,
+                'enabled_imagine': False
+            }, timeout=30.0)
+        logger.info(f"create_conv response: status={r.status_code}, body={r.text[:500]}")
+        if r.status_code in [200, 201]:
+            return conv_id
+        else:
+            raise Exception(f"Failed to create conversation: {r.status_code}")
+
+def extract_prompt(messages):
+    result = []
+    for m in messages:
+        role = m['role'].title()
+        content = m['content']
+        
+        # 支持图片
+        if isinstance(content, list):
+            parts = []
+            for part in content:
+                if part.get('type') == 'text':
+                    parts.append(part['text'])
+                elif part.get('type') == 'image_url':
+                    parts.append(f"[Image: {part['image_url']['url']}]")
+            result.append(f"{role}: {' '.join(parts)}")
+        else:
+            result.append(f"{role}: {content}")
+    
+    return '\n\n'.join(result)
+
+def extract_attachments(messages):
+    attachments = []
+    for m in messages:
+        if isinstance(m['content'], list):
+            for part in m['content']:
+                if part.get('type') == 'image_url':
+                    attachments.append({
+                        'extracted_content': '',
+                        'file_name': 'image.png',
+                        'file_size': 0,
+                        'file_type': 'image/png',
+                        'url': part['image_url']['url']
+                    })
+    return attachments
+
+def enhance_prompt(prompt: str, messages: list) -> str:
+    has_system = any(m['role'] == 'system' for m in messages)
+    if not has_system:
+        return prompt
+    return prompt + "\n\n[Environment: OpenClaw | Tools: web_search, artifacts, repl available]"
+
+def inject_react_prompt(prompt: str, tools: list) -> str:
+    if not tools:
+        return prompt
+    tool_defs = '\n\n'.join([f"{t.get('name', 'unknown')}: {t.get('description', '')}" for t in tools])
+    return prompt + f"""
+
+[Tool Calling Protocol]
+You have access to these tools:
+{tool_defs}
+
+Use this format:
+Thought: [reasoning]
+Action: [tool_name]
+Action Input: [JSON]
+
+After result:
+Observation: [result]
+
+When done:
+Final Answer: [response]
+"""
+
+def parse_react_output(text: str) -> Optional[dict]:
+    action_match = re.search(r'Action:\s*(\w+)', text)
+    input_match = re.search(r'Action Input:\s*(\{[^}]*\})', text)
+    if action_match and input_match:
+        try:
+            return {'type': 'tool_use', 'id': f'tool_{int(datetime.now().timestamp())}',
+                    'name': action_match.group(1), 'input': json.loads(input_match.group(1))}
+        except:
+            return None
+    return None
+
+def anthropic_to_openai_messages(messages: list) -> list:
+    """Convert Anthropic format messages to OpenAI format"""
+    result = []
+    for m in messages:
+        role = m['role']
+        content = m['content']
+
+        if isinstance(content, list):
+            # Handle multi-part content
+            parts = []
+            for part in content:
+                if part.get('type') == 'text':
+                    parts.append({'type': 'text', 'text': part['text']})
+                elif part.get('type') == 'image':
+                    parts.append({'type': 'image_url', 'image_url': {'url': part['source']['data']}})
+            result.append({'role': role, 'content': parts})
+        else:
+            result.append({'role': role, 'content': content})
+
+    return result
+
+@app.post("/v1/messages")
+async def anthropic_messages(request: Request):
+    """Anthropic API format endpoint"""
+    global last_request_time
+    last_request_time = datetime.now()
+
+    try:
+        body = await request.json()
+        auth = request.headers.get('x-api-key') or request.headers.get('Authorization', '').replace('Bearer ', '')
+
+        if not auth:
+            return JSONResponse({"error": {"message": "Missing API key", "type": "authentication_error"}}, 401)
+
+        # Convert to OpenAI format
+        messages = anthropic_to_openai_messages(body.get('messages', []))
+        if body.get('system'):
+            messages.insert(0, {'role': 'system', 'content': body['system']})
+
+        # Process using shared logic
+        return await process_chat_request(auth, messages, body.get('model', 'claude-sonnet-4-6'),
+                                         body.get('stream', False), is_anthropic=True)
+
+    except Exception as e:
+        logger.error(f"Anthropic endpoint error: {e}")
+        return JSONResponse({"error": {"message": str(e), "type": "api_error"}}, 500)
+
+@app.post("/v1/chat/completions")
+@app.post("/chat/completions")
+async def chat_openai(request: Request):
+    """OpenAI API format endpoint"""
+    global last_request_time
+    last_request_time = datetime.now()
+
+    try:
+        body = await request.json()
+        auth = request.headers.get('Authorization', '')
+
+        if not auth.startswith('Bearer '):
+            return JSONResponse({"error": {"message": "Missing auth", "type": "auth_error"}}, 401)
+
+        key = auth.replace('Bearer ', '')
+        return await process_chat_request(key, body.get('messages', []), body.get('model', 'claude-sonnet-4-6'),
+                                         body.get('stream', True), body.get('tools', []), is_anthropic=False)
+
+    except Exception as e:
+        logger.error(f"OpenAI endpoint error: {e}")
+        return JSONResponse({"error": {"message": str(e), "type": "api_error"}}, 500)
+
+@app.post("/v1/claude-code/messages")
+async def claude_code_messages(request: Request):
+    """Claude Code API format endpoint"""
+    global last_request_time
+    last_request_time = datetime.now()
+
+    try:
+        body = await request.json()
+        auth = request.headers.get('x-api-key') or request.headers.get('Authorization', '').replace('Bearer ', '')
+
+        if not auth:
+            return JSONResponse({"error": {"message": "Missing API key", "type": "authentication_error"}}, 401)
+
+        messages = anthropic_to_openai_messages(body.get('messages', []))
+        if body.get('system'):
+            messages.insert(0, {'role': 'system', 'content': body['system']})
+
+        return await process_chat_request(auth, messages, body.get('model', 'claude-sonnet-4-6'),
+                                         body.get('stream', False), is_anthropic=True)
+
+    except Exception as e:
+        logger.error(f"Claude Code endpoint error: {e}")
+        return JSONResponse({"error": {"message": str(e), "type": "api_error"}}, 500)
+
+async def process_chat_request(key: str, messages: list, model: str, stream: bool, tools: list = None, is_anthropic: bool = False):
+    start_time = datetime.now()
+
+    try:
+        logger.info("="*50)
+        logger.info(f"[1] Request received (format: {'Anthropic' if is_anthropic else 'OpenAI'})")
+        logger.info(f"    Model: {model}, Stream: {stream}")
+        logger.info("="*50)
+
+        logger.info(f"[3] Calling get_org_id with sessionKey={key[:20]}...")
+        org_id = await retry_async(lambda: get_org_id(key))
+        if not org_id:
+            logger.error(f"[2] Invalid key")
+            return JSONResponse({"error": {"message": "Invalid key or network error", "type": "auth_error"}}, 401)
+
+        conv_id = conversation_cache.get(key)
+        if not conv_id:
+            conv_id = await retry_async(lambda: create_conv(key, org_id))
+            if conv_id:
+                conversation_cache[key] = conv_id
+                save_cache()
+        if not conv_id:
+            logger.error("Failed to create conversation")
+            return JSONResponse({"error": {"message": "Conv error", "type": "api_error"}}, 500)
+
+        tools = tools or []
+        prompt = extract_prompt(messages)
+        prompt = enhance_prompt(prompt, messages)
+        if tools:
+            prompt = inject_react_prompt(prompt, tools)
+
+        attachments = extract_attachments(messages)
+        payload = {
+            'prompt': prompt,
+            'timezone': 'Asia/Shanghai',
+            'locale': 'en-US',
+            'model': model,
+            'rendering_mode': 'messages',
+            'attachments': attachments,
+            'files': [],
+            'tools': [
+                {"type": "web_search_v0", "name": "web_search"},
+                {"type": "artifacts_v0", "name": "artifacts"},
+                {"type": "repl_v0", "name": "repl"}
+            ]
+        }
+
+        logger.info(f"Sending to Claude: attachments={len(attachments)}")
+
+        # 非流式响应
+        if not stream:
+            return await handle_non_stream(key, org_id, conv_id, payload, model, is_anthropic)
+
+        # 流式响应
+        return await handle_stream(key, org_id, conv_id, payload, model, tools, is_anthropic)
+
+    except Exception as e:
+        duration = (datetime.now() - start_time).total_seconds()
+        logger.error(f"Request failed: {e}, duration={duration}s")
+        return JSONResponse({"error": {"message": str(e), "type": "api_error"}}, 500)
+
+async def handle_non_stream(key, org_id, conv_id, payload, model, is_anthropic):
+    try:
+        full_text = ''
+        headers = {
+            'Content-Type': 'application/json',
+            'Cookie': f'sessionKey={key}',
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+            'Accept': 'text/event-stream',
+            'Referer': 'https://claude.ai/chats',
+            'Origin': 'https://claude.ai'
+        }
+        async with httpx.AsyncClient() as client:
+            async with client.stream('POST',
+                f'https://claude.ai/api/organizations/{org_id}/chat_conversations/{conv_id}/completion',
+                headers=headers, json=payload, timeout=120.0) as response:
+
+                async for line in response.aiter_lines():
+                    if line.startswith('data: '):
+                        try:
+                            data = json.loads(line[6:])
+                            if data.get('type') == 'content_block_delta' and data.get('delta', ).get('text'):
+                                full_text += data['delta']['text']
+                        except:
+                            pass
+
+        if is_anthropic:
+            return JSONResponse({
+                "id": f"msg_{int(datetime.now().timestamp())}",
+                "type": "message",
+                "role": "assistant",
+                "content": [{"type": "text", "text": full_text}],
+                "model": model,
+                "stop_reason": "end_turn"
+            })
+        else:
+            return JSONResponse({
+                "id": f"chatcmpl-{int(datetime.now().timestamp())}",
+                "object": "chat.completion",
+                "created": int(datetime.now().timestamp()),
+                "model": model,
+                "choices": [{
+                    "index": 0,
+                    "message": {"role": "assistant", "content": full_text},
+                    "finish_reason": "stop"
+                }]
+            })
+    except Exception as e:
+        logger.error(f"Non-stream error: {e}")
+        return JSONResponse({"error": {"message": str(e), "type": "api_error"}}, 500)
+
+async def handle_stream(key, org_id, conv_id, payload, model, tools, is_anthropic):
+    async def generate():
+        try:
+            full_text = ''
+            headers = {
+                'Content-Type': 'application/json',
+                'Cookie': f'sessionKey={key}',
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                'Accept': 'text/event-stream',
+                'Referer': 'https://claude.ai/chats',
+                'Origin': 'https://claude.ai'
+            }
+            async with httpx.AsyncClient() as client:
+                async with client.stream('POST',
+                    f'https://claude.ai/api/organizations/{org_id}/chat_conversations/{conv_id}/completion',
+                    headers=headers, json=payload, timeout=120.0) as response:
+
+                    if response.status_code != 200:
+                        error_body = await response.aread()
+                        logger.error(f"Claude API error: {response.status_code}")
+                        yield f'data: {json.dumps({"error": f"Claude returned {response.status_code}"})}\n\n'
+                        return
+
+                    async for line in response.aiter_lines():
+                        if line.startswith('data: '):
+                            try:
+                                data = json.loads(line[6:])
+                                if data.get('type') == 'content_block_delta' and data.get('delta', {}).get('text'):
+                                    text = data['delta']['text']
+                                    full_text += text
+
+                                    # ReAct tool detection
+                                    if tools:
+                                        react_result = parse_react_output(full_text)
+                                        if react_result and react_result['type'] == 'tool_use':
+                                            if is_anthropic:
+                                                chunk = {
+                                                    "type": "content_block_start",
+                                                    "index": 0,
+                                                    "content_block": {
+                                                        "type": "tool_use",
+                                                        "id": react_result['id'],
+                                                        "name": react_result['name'],
+                                                        "input": react_result['input']
+                                                    }
+                                                }
+                                            else:
+                                                chunk = {
+                                                    "id": f"chatcmpl-{int(datetime.now().timestamp())}",
+                                                    "object": "chat.completion.chunk",
+                                                    "created": int(datetime.now().timestamp()),
+                                                    "model": model,
+                                                    "choices": [{
+                                                        "index": 0,
+                                                        "delta": {
+                                                            "tool_calls": [{
+                                                                "id": react_result['id'],
+                                                                "type": "function",
+                                                                "function": {
+                                                                    "name": react_result['name'],
+                                                                    "arguments": json.dumps(react_result['input'])
+                                                                }
+                                                            }]
+                                                        },
+                                                        "finish_reason": "tool_calls"
+                                                    }]
+                                                }
+                                            yield f"data: {json.dumps(chunk)}\n\n"
+                                            yield "data: [DONE]\n\n" if not is_anthropic else ""
+                                            return
+
+                                    # Normal text
+                                    if is_anthropic:
+                                        chunk = {
+                                            "type": "content_block_delta",
+                                            "index": 0,
+                                            "delta": {"type": "text_delta", "text": text}
+                                        }
+                                    else:
+                                        chunk = {
+                                            "id": f"chatcmpl-{int(datetime.now().timestamp())}",
+                                            "object": "chat.completion.chunk",
+                                            "created": int(datetime.now().timestamp()),
+                                            "model": model,
+                                            "choices": [{"index": 0, "delta": {"content": text}, "finish_reason": None}]
+                                        }
+                                    yield f"data: {json.dumps(chunk)}\n\n"
+                            except:
+                                pass
+
+                    if not is_anthropic:
+                        yield "data: [DONE]\n\n"
+        except Exception as e:
+            logger.error(f"Stream error: {e}")
+            yield f"data: {json.dumps({'error': str(e)})}\n\n"
+
+    return StreamingResponse(generate(), media_type="text/event-stream")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)