Upload 2 files

app.py

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

requirements.txt

@@ -0,0 +1,5 @@
+fastapi>=0.115.2
+uvicorn>=0.24.0
+httpx>=0.25.1
+sse-starlette>=1.8.2
+python-multipart>=0.0.6