Update tools_service.py

tools_service.py

@@ -1,204 +1,169 @@
-"""
-Tools Service for LLM Function Calling
-HuggingFace-compatible với prompt engineering
-"""
-import httpx
-from typing import List, Dict, Any, Optional
-import json
-import asyncio
-
-QUAN TRỌNG:
-- event_code PHẢI LÀ metadata.id_use từ context (dạng MongoDB ObjectId)
-- KHÔNG dùng tên sự kiện như "Y-CONCERT" làm event_code
-- CHỈ trả JSON khi BẮT BUỘC cần gọi tool
-- Nếu có thể trả lời từ context sẵn có, đừng gọi tool
-- Sau khi nhận kết quả từ tool, hãy trả lời user bằng ngôn ngữ tự nhiên
-"""
-    
-    async def parse_and_execute(self, llm_response: str) -> Optional[Dict[str, Any]]:
-        """
-        Parse LLM response và execute tool nếu có
-        
-        Returns:
-            None nếu không có tool call
-            Dict với tool result nếu có tool call
-        """
-        # Try to extract JSON from response
-        try:
-            # Tìm JSON block trong response
-            if "```json" in llm_response:
-                json_start = llm_response.find("```json") + 7
-                json_end = llm_response.find("```", json_start)
-                json_str = llm_response[json_start:json_end].strip()
-            elif "{" in llm_response and "}" in llm_response:
-                # Fallback: tìm JSON object đầu tiên
-                json_start = llm_response.find("{")
-                json_end = llm_response.rfind("}") + 1
-                json_str = llm_response[json_start:json_end]
-            else:
-                return None
-            
-            tool_call = json.loads(json_str)
-            
-            # Handle multiple JSON formats from LLM
-            
-            # Format 1: HF API nested wrapper
-            # {"name": "tool_call", "arguments": {"tool_call": true, ...}}
-            if "name" in tool_call and "arguments" in tool_call and isinstance(tool_call["arguments"], dict):
-                if "tool_call" in tool_call["arguments"]:
-                    tool_call = tool_call["arguments"]  # Unwrap
-            
-            # Format 2: Direct tool name format
-            # {"name": "tool.get_event_details", "arguments": {"event_code": "..."}}
-            if "name" in tool_call and "arguments" in tool_call:
-                function_name = tool_call["name"]
-                # Remove "tool." prefix if exists
-                if function_name.startswith("tool."):
-                    function_name = function_name.replace("tool.", "")
-                
-                # Convert to standard format
-                tool_call = {
-                    "tool_call": True,
-                    "function_name": function_name,
-                    "arguments": tool_call["arguments"],
-                    "reason": "Converted from alternate format"
-                }
-            
-            # Validate tool call structure
-            if not tool_call.get("tool_call"):
-                return None
-            
-            function_name = tool_call.get("function_name")
-            arguments = tool_call.get("arguments", {})
-            
-            # Execute tool
-            if function_name == "get_event_details":
-                result = await self._get_event_details(arguments.get("event_code"))
-                return {
-                    "function": function_name,
-                    "arguments": arguments,
-                    "result": result
-                }
-            else:
-                return {
-                    "function": function_name,
-                    "arguments": arguments,
-                    "result": {"success": False, "error": f"Unknown function: {function_name}"}
-                }
-                
-        except (json.JSONDecodeError, KeyError, ValueError) as e:
-            # Không phải tool call, response bình thường
-            return None
-    
-    async def _get_event_details(self, event_code: str) -> Dict[str, Any]:
-        """
-        Call getEventByEventCode API
-        """
-        print(f"\n=== CALLING API get_event_details ===")
-        print(f"Event Code: {event_code}")
-        
-        try:
-            url = f"https://hoalacrent.io.vn/api/v0/event/get-event-by-event-code"
-            params = {"eventCode": event_code}
-            
-            print(f"URL: {url}")
-            print(f"Params: {params}")
-            
-            response = await self.client.get(url, params=params)
-            
-            print(f"Status Code: {response.status_code}")
-            
-            # Log raw response for debugging
-            raw_text = response.text
-            print(f"Raw Response Length: {len(raw_text)} chars")
-            print(f"Raw Response Preview (first 200 chars): {raw_text[:200]}")
-            
-            response.raise_for_status()
-            
-            # Try to parse JSON
-            try:
-                data = response.json()
-            except json.JSONDecodeError as e:
-                print(f"JSON Decode Error: {e}")
-                print(f"Full Raw Response: {raw_text}")
-                return {
-                    "success": False,
-                    "error": f"Invalid JSON response from API",
-                    "message": "API trả về dữ liệu không hợp lệ (không phải JSON)",
-                    "raw_response_preview": raw_text[:500]
-                }
-            
-            print(f"Response Data Keys: {list(data.keys()) if data else 'None'}")
-            print(f"Has 'data' field: {'data' in data}")
-            
-            # Extract relevant fields
-            event = data.get("data", {})
-            
-            if not event:
-                return {
-                    "success": False,
-                    "error": "Event not found",
-                    "message": f"Không tìm thấy sự kiện với mã {event_code}"
-                }
-            
-            # Extract location với nested address structure
-            location_data = event.get("location", {})
-            location = {
-                "address": {
-                    "street": location_data.get("address", {}).get("street", ""),
-                    "city": location_data.get("address", {}).get("city", ""),
-                    "state": location_data.get("address", {}).get("state", ""),
-                    "postalCode": location_data.get("address", {}).get("postalCode", ""),
-                    "country": location_data.get("address", {}).get("country", "")
-                },
-                "coordinates": {
-                    "latitude": location_data.get("coordinates", {}).get("latitude"),
-                    "longitude": location_data.get("coordinates", {}).get("longitude")
-                }
-            }
-            
-            # Build event URL
-            event_code = event.get("eventCode")
-            event_url = f"https://www.festavenue.site/user/event/{event_code}" if event_code else None
-            
-            return {
-                "success": True,
-                "event_code": event_code,
-                "event_name": event.get("eventName"),
-                "event_url": event_url,  # NEW: Direct link to event page
-                "description": event.get("description"),
-                "short_description": event.get("shortDescription"),
-                "start_time": event.get("startTimeEventTime"),
-                "end_time": event.get("endTimeEventTime"),
-                "start_sale": event.get("startTicketSaleTime"),
-                "end_sale": event.get("endTicketSaleTime"),
-                "location": location,  # Full nested structure
-                "contact": {
-                    "email": event.get("publicContactEmail"),
-                    "phone": event.get("publicContactPhone"),
-                    "website": event.get("website")
-                },
-                "capacity": event.get("capacity"),
-                "hashtags": event.get("hashtags", [])
-            }
-            
-            print(f"Successfully extracted event data for: {event.get('eventName')}")
-            print(f"=== API CALL COMPLETE ===")
-            return result
-            
-        except httpx.HTTPStatusError as e:
-            return {
-                "success": False,
-                "error": f"HTTP {e.response.status_code}",
-                "message": f"API trả về lỗi khi truy vấn sự kiện {event_code}"
-            }
-        except Exception as e:
-            return {
-                "success": False,
-                "error": str(e),
-                "message": "Không thể kết nối đến API để lấy thông tin sự kiện"
-            }
-    
-    async def close(self):
-        """Close HTTP client"""
-        await self.client.aclose()
+"""
+Tools Service for LLM Function Calling
+HuggingFace-compatible với prompt engineering
+"""
+import httpx
+from typing import List, Dict, Any, Optional
+import json
+import asyncio
+
+
+class ToolsService:
+    """
+    Manages external API tools that LLM can call via prompt engineering
+    """
+    
+    def __init__(self, base_url: str = "https://hoalacrent.io.vn/api/v0"):
+        self.base_url = base_url
+        self.client = httpx.AsyncClient(timeout=10.0)
+    
+    def get_tools_definition(self) -> List[Dict]:
+        """
+        Return list of tool definitions (OpenAI format style)
+        Used for constructing system prompt
+        """
+        return [
+            {
+                "name": "search_events",
+                "description": "Tìm kiếm sự kiện phù hợp theo từ khóa, vibe, hoặc thời gian.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "query": {"type": "string", "description": "Từ khóa tìm kiếm (VD: 'nhạc rock', 'hài kịch')"},
+                        "vibe": {"type": "string", "description": "Vibe/Mood (VD: 'chill', 'sôi động', 'hẹn hò')"},
+                        "time": {"type": "string", "description": "Thời gian (VD: 'cuối tuần này', 'tối nay')"}
+                    }
+                }
+            },
+            {
+                "name": "get_event_details",
+                "description": "Lấy thông tin chi tiết (giá, địa điểm, thời gian) của sự kiện.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "event_id": {"type": "string", "description": "ID của sự kiện (MongoDB ID)"}
+                    },
+                    "required": ["event_id"]
+                }
+            },
+            {
+                "name": "get_purchased_events",
+                "description": "Kiểm tra lịch sử các sự kiện user đã mua vé hoặc tham gia.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "user_id": {"type": "string", "description": "ID của user"}
+                    },
+                    "required": ["user_id"]
+                }
+            },
+            {
+                "name": "save_feedback",
+                "description": "Lưu đánh giá/feedback của user về sự kiện.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "event_id": {"type": "string", "description": "ID sự kiện"},
+                        "rating": {"type": "integer", "description": "Số sao đánh giá (1-5)"},
+                        "comment": {"type": "string", "description": "Nội dung nhận xét"}
+                    },
+                    "required": ["event_id", "rating"]
+                }
+            },
+            {
+                "name": "save_lead",
+                "description": "Lưu thông tin khách hàng quan tâm (Lead).",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "email": {"type": "string"},
+                        "phone": {"type": "string"},
+                        "interest": {"type": "string"}
+                    }
+                }
+            }
+        ]
+
+    async def execute_tool(self, tool_name: str, arguments: Dict) -> Any:
+        """
+        Execute a tool by name with arguments
+        """
+        print(f"🔧 Executing Tool: {tool_name} with args: {arguments}")
+        
+        try:
+            if tool_name == "get_event_details":
+                return await self._get_event_details(arguments.get("event_id") or arguments.get("event_code"))
+            
+            elif tool_name == "get_purchased_events":
+                return await self._get_purchased_events(arguments.get("user_id"))
+            
+            elif tool_name == "save_feedback":
+                return await self._save_feedback(
+                    arguments.get("event_id"),
+                    arguments.get("rating"),
+                    arguments.get("comment")
+                )
+            
+            elif tool_name == "search_events":
+                # Note: This usually requires RAG service, so we return a special signal
+                # The Agent Service will handle RAG search
+                return {"action": "run_rag_search", "query": arguments}
+            
+            elif tool_name == "save_lead":
+                # Placeholder for lead saving
+                return {"success": True, "message": "Lead saved successfully"}
+            
+            else:
+                return {"error": f"Unknown tool: {tool_name}"}
+                
+        except Exception as e:
+            print(f"⚠️ Tool Execution Error: {e}")
+            return {"error": str(e)}
+
+    async def _get_event_details(self, event_id: str) -> Dict:
+        """Call API to get event details"""
+        if not event_id:
+            return {"error": "Missing event_id"}
+            
+        try:
+            url = f"{self.base_url}/event/get-event-by-id"
+            
+            response = await self.client.get(url, params={"id": event_id})
+            if response.status_code == 200:
+                data = response.json()
+                if data.get("success"):
+                    return data.get("data")
+            return {"error": "Event not found", "details": response.text}
+        except Exception as e:
+            return {"error": str(e)}
+
+    async def _get_purchased_events(self, user_id: str) -> List[Dict]:
+        """Call API to get purchased events for user"""
+        if not user_id:
+            return []
+            
+        try:
+            url = f"{self.base_url}/event/get-purchase-event-by-user-id/{user_id}"
+            print(f"🔍 Calling API: {url}")
+            
+            response = await self.client.get(url)
+            if response.status_code == 200:
+                data = response.json()
+                # API returns {data: [...]}
+                return data.get("data", [])
+            
+            print(f"⚠️ API Error: {response.status_code} - {response.text}")
+            return []
+        except Exception as e:
+            print(f"⚠️ API Exception: {e}")
+            return []
+
+    async def _save_feedback(self, event_id: str, rating: int, comment: str) -> Dict:
+        """Save feedback (Mock or Real API)"""
+        # TODO: Implement real API call when available
+        print(f"📝 Saving Feedback: Event={event_id}, Rating={rating}, Comment={comment}")
+        return {"success": True, "message": "Feedback recorded"}
+
+    async def close(self):
+        """Close HTTP client"""
+        await self.client.aclose()