feat: add logs

app.py

@@ -122,41 +122,136 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# CRITICAL: Add the missing endpoint that Agent-S expects
+# Add this to your current /v1/ground/chat/completions endpoint
 @app.post("/v1/ground/chat/completions")
 async def chat_completions(request: Request):
     """
     Chat completions endpoint that Agent-S expects
     """
     try:
-        # Parse the request body
-        body = await request.json()
-        
-        # Extract image and prompt from the request
-        # Agent-S might send data in different formats
-        if "data" in body and len(body["data"]) >= 2:
-            image = body["data"][0]  # First element is image
-            prompt = body["data"][1]  # Second element is prompt
-        elif "image" in body and "prompt" in body:
-            image = body["image"]
-            prompt = body["prompt"]
-        else:
+        print("=" * 60)
+        print("�� DEBUG: New request received")
+        print("=" * 60)
+        
+        # DEBUG: Log the raw request
+        body = await request.body()
+        print(f"�� RAW REQUEST BODY (bytes): {body}")
+        print(f"�� RAW REQUEST BODY (string): {body.decode('utf-8', errors='ignore')}")
+        
+        # DEBUG: Log the headers
+        headers = dict(request.headers)
+        print(f"📋 REQUEST HEADERS:")
+        for key, value in headers.items():
+            print(f"   {key}: {value}")
+        
+        # DEBUG: Log the request method and URL
+        print(f"🌐 REQUEST METHOD: {request.method}")
+        print(f"🌐 REQUEST URL: {request.url}")
+        
+        # DEBUG: Try to parse as JSON
+        try:
+            json_body = await request.json()
+            print(f"✅ PARSED JSON SUCCESSFULLY:")
+            print(f"   {json.dumps(json_body, indent=2)}")
+            
+            # DEBUG: Analyze the JSON structure
+            if isinstance(json_body, dict):
+                print(f"🔍 JSON KEYS: {list(json_body.keys())}")
+                
+                if "messages" in json_body:
+                    messages = json_body["messages"]
+                    print(f"💬 MESSAGES COUNT: {len(messages)}")
+                    for i, msg in enumerate(messages):
+                        print(f"   Message {i}: role='{msg.get('role')}', content='{msg.get('content', '')[:100]}...'")
+                
+                if "model" in json_body:
+                    print(f"🤖 MODEL: {json_body['model']}")
+                
+                if "temperature" in json_body:
+                    print(f"🌡️ TEMPERATURE: {json_body['temperature']}")
+            
+        except Exception as parse_error:
+            print(f"❌ JSON PARSE ERROR: {parse_error}")
+            print(f"❌ ERROR TYPE: {type(parse_error).__name__}")
+            print(f"❌ ERROR DETAILS: {str(parse_error)}")
+            
+            # Try to get more info about the parsing error
+            try:
+                # Try to read the body again
+                await request.body()  # Reset the body stream
+                raw_text = await request.body()
+                print(f"📝 RAW TEXT (second attempt): {raw_text.decode('utf-8', errors='ignore')}")
+            except Exception as e2:
+                print(f"❌ SECOND ATTEMPT ERROR: {e2}")
+            
+            return JSONResponse(
+                status_code=400,
+                content={"error": f"Invalid JSON: {str(parse_error)}", "status": "failed"}
+            )
+        
+        print("=" * 60)
+        print("✅ REQUEST PARSED SUCCESSFULLY - CONTINUING...")
+        print("=" * 60)
+        
+        # Continue with your existing logic...
+        # Extract the user message from the chat format
+        user_message = None
+        if "messages" in json_body:
+            for message in json_body["messages"]:
+                if message.get("role") == "user":
+                    user_message = message.get("content")
+                    break
+        
+        if not user_message:
+            print(f"❌ NO USER MESSAGE FOUND")
             return JSONResponse(
                 status_code=400,
-                content={"error": "Invalid request format", "status": "failed"}
+                content={"error": "No user message found in request", "status": "failed"}
             )
         
+        print(f"📝 USER MESSAGE EXTRACTED: {user_message}")
+        
         # Process the request
-        result = process_grounding(image, prompt)
+        result = process_grounding("mock_image", user_message)
+        print(f"🎯 GROUNDING RESULT: {result}")
         
-        return JSONResponse(content=result)
+        # Format response in the expected chat completions format
+        response = {
+            "id": "chatcmpl-123",
+            "object": "chat.completion",
+            "created": 1677652288,
+            "model": json_body.get("model", "ui-tars-1.5-7b"),
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": json.dumps(result)
+                    },
+                    "finish_reason": "stop"
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 10,
+                "completion_tokens": 20,
+                "total_tokens": 30
+            }
+        }
+        
+        print(f"📤 SENDING RESPONSE: {json.dumps(response, indent=2)}")
+        return JSONResponse(content=response)
         
     except Exception as e:
+        print(f"❌ UNEXPECTED ERROR: {str(e)}")
+        print(f"❌ ERROR TYPE: {type(e).__name__}")
+        import traceback
+        print(f"❌ TRACEBACK: {traceback.format_exc()}")
+        
         return JSONResponse(
             status_code=500,
             content={"error": f"Internal server error: {str(e)}", "status": "failed"}
         )
-
+    
 # Keep existing endpoints for compatibility
 @app.post("/v1/ground")
 async def agent_s_grounding(request: Request):