Delete app.py

app.py

@@ -1,311 +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
-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))
-
-app = FastAPI(title="Claude Proxy")
-app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
-
-# 文件持久化
-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:  # 1小时内有请求，频繁保活
-            await asyncio.sleep(1800)  # 30分钟
-        else:  # 空闲，降低频率
-            await asyncio.sleep(6 * 3600)  # 6小时
-        
-        try:
-            async with httpx.AsyncClient() as client:
-                url = os.getenv("SPACE_URL", "")
-                if url:
-                    await client.get(f"{url}/health")
-        except:
-            pass
-
-@app.on_event("startup")
-async def startup():
-    load_cache()
-    asyncio.create_task(keep_alive())
-
-@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]:
-    try:
-        async with httpx.AsyncClient() as client:
-            r = await client.get('https://claude.ai/api/organizations',
-                headers={'Cookie': f'sessionKey={key}', 'User-Agent': 'Mozilla/5.0'}, timeout=30.0)
-            if r.status_code == 200:
-                data = r.json()
-                return data[0]['uuid'] if data else None
-    except:
-        pass
-    return None
-
-async def create_conv(key: str, org_id: str) -> Optional[str]:
-    try:
-        conv_id = str(uuid.uuid4())
-        async with httpx.AsyncClient() as client:
-            r = await client.post(f'https://claude.ai/api/organizations/{org_id}/chat_conversations',
-                headers={'Content-Type': 'application/json', 'Cookie': f'sessionKey={key}', 'User-Agent': 'Mozilla/5.0'},
-                json={'uuid': conv_id, 'name': '', 'include_conversation_preferences': True}, timeout=30.0)
-            if r.status_code == 200:
-                return r.json().get('uuid', conv_id)
-    except:
-        pass
-    return None
-
-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['name']}: {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
-
-@app.post("/v1/chat/completions")
-async def chat(request: Request):
-    global last_request_time
-    last_request_time = datetime.now()
-    start_time = datetime.now()
-    
-    try:
-        body = await request.json()
-        auth = request.headers.get('Authorization', '')
-        
-        logger.info(f"Request received: model={body.get('model', 'claude-sonnet-4-6')}")
-        
-        if not auth.startswith('Bearer '):
-            return JSONResponse({"error": {"message": "Missing auth", "type": "auth_error"}}, 401)
-        
-        key = auth.replace('Bearer ', '')
-        org_id = await retry_async(lambda: get_org_id(key))
-        if not org_id:
-            logger.error("Invalid sessionKey")
-            return JSONResponse({"error": {"message": "Invalid key", "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)
-        
-        messages = body.get('messages', [])
-        tools = body.get('tools', [])
-        prompt = extract_prompt(messages)
-        prompt = enhance_prompt(prompt, messages)
-        if tools:
-            prompt = inject_react_prompt(prompt, tools)
-        
-        attachments = extract_attachments(messages)
-        model = body.get('model', 'claude-sonnet-4-6')
-        payload = {
-            'prompt': prompt,
-            'timezone': body.get('timezone', 'Asia/Shanghai'),
-            'locale': body.get('locale', 'zh-CN'),
-            '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)}")
-        
-        async def generate():
-            try:
-                full_text = ''
-                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={'Content-Type': 'application/json', 'Cookie': f'sessionKey={key}', 'User-Agent': 'Mozilla/5.0'},
-                        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'):
-                                        text = data['delta']['text']
-                                        full_text += text
-                                        
-                                        # ReAct: 检测工具调用
-                                        react_result = parse_react_output(full_text)
-                                        if react_result and react_result['type'] == 'tool_use':
-                                            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"
-                                            return
-                                        
-                                        # 正常文本
-                                        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
-                        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")
-    
-    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)