Update app.py

app.py

@@ -225,39 +225,79 @@ async def get_chatwoot_conversation(conversation_id: int) -> Optional[dict]:
                 
                 msgs_resp.raise_for_status()
                 
-                # The API returns the payload with meta and messages
+                # Parse the JSON response
                 response_data = msgs_resp.json()
+                print(f"📊 Response data type: {type(response_data).__name__}")
+                
+                # Handle different response formats
+                if isinstance(response_data, dict):
+                    # If the response has a 'payload' key, use that
+                    messages = response_data.get('payload', [])
+                    meta = response_data.get('meta', {})
+                elif isinstance(response_data, list):
+                    # If the response is directly a list of messages
+                    messages = response_data
+                    meta = {}
+                else:
+                    print(f"⚠️ Unexpected response format: {type(response_data)}")
+                    return None
                 
-                # Extract messages from the response
-                messages = response_data.get('payload', [])
                 if not isinstance(messages, list):
-                    print(f"⚠️ Unexpected messages format. Expected list, got: {type(messages)}")
+                    print(f"⚠️ Messages is not a list: {type(messages)}")
                     return None
                     
                 print(f"\n📩 Successfully parsed {len(messages)} messages")
                 if messages:
-                    print(f"First message: {messages[0].get('content', 'No content')[:100]}...")
+                    first_msg = messages[0]
+                    print(f"First message type: {type(first_msg).__name__}")
+                    print(f"First message keys: {list(first_msg.keys()) if hasattr(first_msg, 'keys') else 'N/A'}")
                 
-                # Filter out system messages and format for Slack
+                # Process and filter messages
                 filtered_messages = []
                 for msg in messages:
-                    # Only include messages with content and from known senders
-                    if msg.get('content') and msg.get('sender') and msg.get('sender').get('type') in ['contact', 'user']:
+                    try:
+                        # Skip if no content or sender info
+                        if not msg.get('content') or not isinstance(msg.get('content'), str):
+                            continue
+                            
+                        # Get sender info, handle different formats
+                        sender = msg.get('sender', {})
+                        sender_type = None
+                        sender_name = 'Unknown'
+                        
+                        if isinstance(sender, dict):
+                            sender_type = sender.get('type')
+                            sender_name = sender.get('name') or sender.get('available_name', 'Unknown')
+                        
+                        # Only include relevant message types
+                        if sender_type not in ['contact', 'user', 'agent']:
+                            continue
+                            
+                        # Create the filtered message
                         filtered_msg = {
                             'id': msg.get('id'),
-                            'content': msg.get('content'),
+                            'content': msg['content'],
                             'created_at': msg.get('created_at'),
                             'sender': {
-                                'type': msg.get('sender', {}).get('type'),
-                                'name': msg.get('sender', {}).get('name', 'Unknown')
+                                'type': sender_type,
+                                'name': sender_name
                             },
-                            'message_type': msg.get('message_type')
+                            'message_type': 'incoming' if msg.get('message_type') == 0 else 'outgoing',
+                            'timestamp': msg.get('created_at')
                         }
                         filtered_messages.append(filtered_msg)
+                        
+                    except Exception as e:
+                        print(f"⚠️ Error processing message {msg.get('id')}: {str(e)}")
+                        continue
+                
+                print(f"✅ Filtered to {len(filtered_messages)} relevant messages")
+                
+                # Sort messages by timestamp if available
+                filtered_messages.sort(key=lambda x: x.get('timestamp', 0))
                 
-                # Return the filtered messages with metadata
                 return {
-                    'meta': response_data.get('meta', {}),
+                    'meta': meta,
                     'payload': filtered_messages
                 }
                 
@@ -428,6 +468,7 @@ async def _process_slack_command(conversation_id: str, response_url: str):
             )
 
 async def send_chatwoot_message(conversation_id: str, content: str):
+    """Send a message to a Chatwoot conversation"""
     message_payload = {
         "content": content,
         "message_type": "outgoing",
@@ -437,19 +478,53 @@ async def send_chatwoot_message(conversation_id: str, content: str):
     }
 
     try:
-        async with httpx.AsyncClient() as http:
-            url = f"{CHATWOOT_BASE_URL}/api/v1/accounts/{CHATWOOT_ACCOUNT_ID}/conversations/{conversation_id}/messages"
-            print("📤 Sending to Chatwoot:", url)
-            print("📦 Payload:", json.dumps(message_payload, indent=2))
+        url = f"{CHATWOOT_BASE_URL}/api/v1/accounts/{CHATWOOT_ACCOUNT_ID}/conversations/{conversation_id}/messages"
+        headers = {
+            "Content-Type": "application/json",
+            "api_access_token": CHATWOOT_API_KEY,
+        }
+        
+        print(f"📤 Sending to Chatwoot: {url}")
+        print(f"🔑 Using API key: {CHATWOOT_API_KEY[:5]}..." if CHATWOOT_API_KEY else "❌ No API key provided!")
+        print("📦 Payload:", json.dumps(message_payload, indent=2))
+        print("🔑 Headers:", json.dumps({k: '***' if 'token' in k.lower() or 'key' in k.lower() else v for k, v in headers.items()}, indent=2))
 
-            resp = await http.get(
+        async with httpx.AsyncClient() as http:
+            # First, try to get the conversation to verify access
+            conv_url = f"{CHATWOOT_BASE_URL}/api/v1/accounts/{CHATWOOT_ACCOUNT_ID}/conversations/{conversation_id}"
+            print(f"🔍 Checking conversation access: {conv_url}")
+            
+            # Test GET request to verify conversation access
+            test_resp = await http.get(conv_url, headers=headers)
+            print(f"🔍 Conversation check status: {test_resp.status_code}")
+            print(f"🔍 Response: {test_resp.text[:500]}..." if test_resp.text else "No response body")
+            
+            if test_resp.status_code != 200:
+                error_msg = f"Failed to access conversation: {test_resp.status_code} - {test_resp.text}"
+                print(f"❌ {error_msg}")
+                return {"status": "error", "message": error_msg}
+
+            # If we can access the conversation, try to send the message
+            print("✅ Conversation access verified. Sending message...")
+            resp = await http.post(
                 url,
-                headers={
-                    "Content-Type": "application/json",
-                    "api_access_token": CHATWOOT_API_KEY,
-                },
-                json=message_payload,
+                headers=headers,
+                json=message_payload
             )
-            print("📬 Chatwoot Response:", resp.status_code, resp.text)
+            print(f"📬 Chatwoot Response Status: {resp.status_code}")
+            print(f"📬 Response Body: {resp.text}")
+            
+            if resp.status_code != 200:
+                error_msg = f"Failed to send message: {resp.status_code} - {resp.text}"
+                print(f"❌ {error_msg}")
+                return {"status": "error", "message": error_msg}
+                
+            return {"status": "success", "data": resp.json()}
+            
+    except httpx.HTTPStatusError as e:
+        error_msg = f"HTTP error occurred: {str(e)}"
+        print(f"❌ {error_msg}")
+        print(f"Response: {e.response.text if hasattr(e, 'response') else 'No response'}")
+        return {"status": "error", "message": error_msg}
     except Exception as e:
         print("❌ Chatwoot Send Error:", e)