Delete app.py

app.py

@@ -1,549 +0,0 @@
-"""
-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)