Upload app.py

app.py

@@ -15,25 +15,12 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(level
 logger = logging.getLogger(__name__)
 
 # Constants
-PORT = 7860
+PORT = 7860 
 REVE_API_URL = "https://preview.reve.art/api/misc/chat"
 RATE_LIMIT = 4
 RATE_LIMIT_WINDOW = 60
 HASH_SALT = os.urandom(16).hex()
 
-LATEST_VERSION_MAPPING = {
-    "claude-3-7-sonnet-latest": "claude-3-7-sonnet-20250219",
-    "claude-3-5-sonnet-latest": "claude-3-5-sonnet-20241022",
-    "claude-3-5-haiku-latest": "claude-3-5-haiku-20241022"
-}
-
-MODEL_MAPPING = {
-    "claude-3-7-sonnet-20250219": "llm_claude_sonnet_3_7",
-    "claude-3-5-sonnet-20241022": "llm_claude_sonnet_3_5_v2",
-    "claude-3-5-sonnet-20240620": "llm_claude_sonnet_3_5",
-    "claude-3-5-haiku-20241022": "llm_claude_haiku_3_5_v2"
-}
-
 # Rate limiting store
 rate_limit_store = defaultdict(lambda: deque(maxlen=RATE_LIMIT))
 
@@ -151,15 +138,19 @@ def get_next_token():
     return token
 
 def convert_anthropic_to_reve_request(anthropic_req):
-    model = anthropic_req.get("model", "claude-3-7-sonnet-latest")
+    model_name = anthropic_req.get("model", "claude-3-7-sonnet-20250219")
     
-    # Resolve latest version to specific version if needed
-    if model in LATEST_VERSION_MAPPING:
-        model = LATEST_VERSION_MAPPING[model]
-        
-    reve_model = MODEL_MAPPING.get(model, "llm_claude_sonnet_3_7")
-
-    system_prompt = anthropic_req.get("system", "")
+    reve_model = "llm_claude_sonnet_3_7"
+    
+    if "claude-3-5-sonnet" in model_name:
+        if "20241022" in model_name:
+            reve_model = "llm_claude_sonnet_3_5_v2"
+        else:
+            reve_model = "llm_claude_sonnet_3_5"
+    elif "claude-3-5-haiku" in model_name:
+        reve_model = "llm_claude_haiku_3_5_v2"
+    
+    system_prompt = anthropic_req.get("system", "You are a helpful assistant.")
     
     if isinstance(system_prompt, list):
         system_text_chunks = []
@@ -170,58 +161,74 @@ def convert_anthropic_to_reve_request(anthropic_req):
                 system_text_chunks.append(item)
         system_prompt = "\n".join(system_text_chunks)
     
-    max_tokens = anthropic_req.get("max_tokens", 8192)
-    
-    temperature = anthropic_req.get("temperature", 1.0)
+    temperature = anthropic_req.get("temperature", 0.5)
     temperature_percent = int(temperature * 100)
     
+    max_tokens = anthropic_req.get("max_tokens", 4000)
+    
     conversation = []
+    
     for msg in anthropic_req.get("messages", []):
         role = msg.get("role", "user")
-        
         content = msg.get("content", "")
+        
+        reve_message = {"role": role}
+        
         multi_content = []
         
         if isinstance(content, str):
-            multi_content = [{"text": content}]
+            multi_content.append({"text": content})
+            reve_message["content"] = content
         elif isinstance(content, list):
+            text_parts = []
             for item in content:
                 if isinstance(item, str):
+                    text_parts.append(item)
                     multi_content.append({"text": item})
                 elif isinstance(item, dict):
                     if item.get("type") == "text":
+                        text_parts.append(item.get("text", ""))
                         multi_content.append({"text": item.get("text", "")})
                     elif item.get("type") == "image":
-                        src = item["source"]
+                        src = item.get("source", {})
                         multi_content.append({
                             "image": {
-                                "type": src["type"],
-                                "media_type": src["type"],
-                                "data": src["data"]
+                                "type": src.get("type", ""),
+                                "media_type": src.get("media_type", src.get("type", "")),
+                                "data": src.get("data", "")
                             }
                         })
+            
+            if text_parts:
+                reve_message["content"] = " ".join(text_parts)
         
-        conversation.append({
-            "role": role,
-            "multi_content": multi_content
-        })
+        reve_message["multi_content"] = multi_content
+        conversation.append(reve_message)
     
     reve_req = {
-        "model": reve_model,
-        "max_length": max_tokens,
         "system_prompt": system_prompt,
+        "conversation": conversation,
+        "model": reve_model,
         "temperature_percent": temperature_percent,
-        "conversation": conversation
+        "max_length": max_tokens
     }
     
-    return reve_req
+    return reve_req, reve_model
 
 def convert_reve_to_anthropic_response(reve_resp, reve_model):
-    content = reve_resp.get("response", "")
+    response_text = reve_resp.get("response", "")
+    stop_reason = reve_resp.get("stop_reason", "end_turn")
+    prompt_tokens = reve_resp.get("prompt_tokens", 0)
+    completion_tokens = reve_resp.get("completion_tokens", 0)
+    
+    anthropic_model = "claude-3-7-sonnet-20250219"  # default
     
-    # Find the corresponding Anthropic model
-    anthropic_model = next((anthr_model for anthr_model, rev_model in MODEL_MAPPING.items() 
-                         if rev_model == reve_model), "claude-3-7-sonnet-20250219")
+    if reve_model == "llm_claude_sonnet_3_5_v2":
+        anthropic_model = "claude-3-5-sonnet-20241022"
+    elif reve_model == "llm_claude_sonnet_3_5":
+        anthropic_model = "claude-3-5-sonnet-20240620"
+    elif reve_model == "llm_claude_haiku_3_5_v2":
+        anthropic_model = "claude-3-5-haiku-20241022"
     
     anthropic_resp = {
         "id": "msg_" + os.urandom(8).hex(),
@@ -230,15 +237,15 @@ def convert_reve_to_anthropic_response(reve_resp, reve_model):
         "content": [
             {
                 "type": "text",
-                "text": content
+                "text": response_text
             }
         ],
         "model": anthropic_model,
-        "stop_reason": reve_resp.get("stop_reason", "end_turn"),
+        "stop_reason": stop_reason,
         "stop_sequence": None,
         "usage": {
-            "input_tokens": reve_resp.get("prompt_tokens", 0),
-            "output_tokens": reve_resp.get("completion_tokens", 0)
+            "input_tokens": prompt_tokens,
+            "output_tokens": completion_tokens
         }
     }
     
@@ -275,8 +282,7 @@ async def handle_anthropic_request(request):
                 }
             }, status=400)
         
-        reve_req = convert_anthropic_to_reve_request(anthropic_req)
-        reve_model = reve_req['model']
+        reve_req, reve_model = convert_anthropic_to_reve_request(anthropic_req)
         logger.info(f"Doing request with model {reve_model}")
 
         tried_tokens = set()
@@ -294,7 +300,8 @@ async def handle_anthropic_request(request):
             
             headers = {
                 "Authorization": current_token,
-                "Content-Type": "application/json; charset=utf-8"
+                "Content-Type": "application/json",
+                "Accept": "application/json"
             }
             
             try:
@@ -341,7 +348,7 @@ async def main():
     app = web.Application()
     app.router.add_post('/v1/messages', handle_anthropic_request)
     
-    logger.info(f"Async proxy server running on port {PORT}")
+    logger.info(f"Reve.art API proxy running on port {PORT}")
     logger.info(f"Rate limit set to {RATE_LIMIT} requests per {RATE_LIMIT_WINDOW} seconds per IP")
     
     runner = web.AppRunner(app)