Update agent_service.py

agent_service.py

@@ -139,9 +139,95 @@ class AgentService:
         }
     
     def _get_system_prompt(self, mode: str) -> str:
-        """Get system prompt for selected mode"""
+        """Get system prompt for selected mode with tools definition"""
         prompt_key = f"{mode}_agent" if mode in ["sales", "feedback"] else "sales_agent"
-        return self.prompts.get(prompt_key, "")
+        base_prompt = self.prompts.get(prompt_key, "")
+        
+        # Add tools definition
+        tools_definition = self._get_tools_definition()
+        
+        return f"{base_prompt}\n\n{tools_definition}"
+    
+    def _get_tools_definition(self) -> str:
+        """Get tools definition in text format for prompt"""
+        return """
+# AVAILABLE TOOLS
+
+You can call the following tools when needed. To call a tool, output a JSON block like this:
+
+```json
+{
+  "tool_call": "tool_name",
+  "arguments": {
+    "arg1": "value1",
+    "arg2": "value2"
+  }
+}
+```
+
+## Tools List:
+
+### 1. search_events
+Search for events matching user criteria.
+Arguments:
+- query (string): Search keywords
+- vibe (string, optional): Mood/vibe (e.g., "chill", "sôi động")
+- time (string, optional): Time period (e.g., "cuối tuần này")
+
+Example:
+```json
+{"tool_call": "search_events", "arguments": {"query": "nhạc rock", "vibe": "sôi động"}}
+```
+
+### 2. get_event_details
+Get detailed information about a specific event.
+Arguments:
+- event_id (string): Event ID from search results
+
+Example:
+```json
+{"tool_call": "get_event_details", "arguments": {"event_id": "6900ae38eb03f29702c7fd1d"}}
+```
+
+### 3. get_purchased_events (Feedback mode only)
+Check which events the user has attended.
+Arguments:
+- user_id (string): User ID
+
+Example:
+```json
+{"tool_call": "get_purchased_events", "arguments": {"user_id": "user_123"}}
+```
+
+### 4. save_feedback
+Save user's feedback/review for an event.
+Arguments:
+- event_id (string): Event ID
+- rating (integer): 1-5 stars
+- comment (string, optional): User's comment
+
+Example:
+```json
+{"tool_call": "save_feedback", "arguments": {"event_id": "abc123", "rating": 5, "comment": "Tuyệt vời!"}}
+```
+
+### 5. save_lead
+Save customer contact information.
+Arguments:
+- email (string, optional): Email address
+- phone (string, optional): Phone number
+- interest (string, optional): What they're interested in
+
+Example:
+```json
+{"tool_call": "save_lead", "arguments": {"email": "user@example.com", "interest": "Rock show"}}
+```
+
+**IMPORTANT:**
+- Call tools ONLY when you need real-time data
+- After receiving tool results, respond naturally to the user
+- Don't expose raw JSON to users - always format nicely
+"""
     
     def _build_messages(
         self,
@@ -162,22 +248,29 @@ class AgentService:
     
     async def _call_llm(self, messages: List[Dict]) -> str:
         """
-        Call HuggingFace LLM
-        Uses advanced_rag's chat method
+        Call HuggingFace LLM directly using InferenceClient
         """
         try:
+            from huggingface_hub import AsyncInferenceClient
+            
             # Build prompt from messages
             prompt = self._messages_to_prompt(messages)
             
-            # Call HF API via advanced_rag
-            response = await self.advanced_rag.chat_completion(
-                user_prompt=prompt,
-                context="",  # Context is already in system prompt
-                chat_history=[],  # History is in messages
-                token=self.hf_token
-            )
+            # Create async client
+            client = AsyncInferenceClient(token=self.hf_token)
+            
+            # Call HF API
+            response_text = ""
+            async for token in await client.text_generation(
+                prompt=prompt,
+                model="openai/gpt-oss-20b",
+                max_new_tokens=512,
+                temperature=0.7,
+                stream=True
+            ):
+                response_text += token
             
-            return response
+            return response_text
         except Exception as e:
             print(f"⚠️ LLM Call Error: {e}")
             return "Xin lỗi, tôi đang gặp chút vấn đề kỹ thuật. Bạn thử lại sau nhé!"
@@ -248,51 +341,94 @@ class AgentService:
     
     def _parse_tool_call(self, llm_response: str) -> Optional[Dict]:
         """
-        Parse LLM response to detect tool calls
+        Parse LLM response to detect tool calls using structured JSON
         
         Returns:
             {"tool_name": "...", "arguments": {...}} or None
         """
         import json
+        import re
         
-        # Simple heuristic: Check if response mentions tools
-        # In a real system, LLM should output structured JSON
+        # Method 1: Look for JSON code block
+        json_match = re.search(r'```json\s*(\{.*?\})\s*```', llm_response, re.DOTALL)
+        if json_match:
+            try:
+                data = json.loads(json_match.group(1))
+                return self._extract_tool_from_json(data)
+            except json.JSONDecodeError:
+                pass
+        
+        # Method 2: Look for inline JSON object
+        # Find all potential JSON objects
+        json_objects = re.findall(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}', llm_response)
+        for json_str in json_objects:
+            try:
+                data = json.loads(json_str)
+                tool_call = self._extract_tool_from_json(data)
+                if tool_call:
+                    return tool_call
+            except json.JSONDecodeError:
+                continue
         
-        # For now, we'll use keyword detection
-        # TODO: Train LLM to output proper tool call JSON
+        # Method 3: Nested JSON (for complex structures)
+        try:
+            # Find outermost curly braces
+            if '{' in llm_response and '}' in llm_response:
+                start = llm_response.find('{')
+                # Find matching closing brace
+                count = 0
+                for i, char in enumerate(llm_response[start:], start):
+                    if char == '{':
+                        count += 1
+                    elif char == '}':
+                        count -= 1
+                        if count == 0:
+                            json_str = llm_response[start:i+1]
+                            data = json.loads(json_str)
+                            return self._extract_tool_from_json(data)
+        except (json.JSONDecodeError, ValueError):
+            pass
         
-        response_lower = llm_response.lower()
+        return None
+    
+    def _extract_tool_from_json(self, data: dict) -> Optional[Dict]:
+        """
+        Extract tool call information from parsed JSON
         
-        # Check for search intent
-        if any(keyword in response_lower for keyword in ["tìm kiếm", "search", "tìm event"]):
-            # Extract query from response
+        Supports multiple formats:
+        - {"tool_call": "search_events", "arguments": {...}}
+        - {"function": "search_events", "parameters": {...}}
+        - {"name": "search_events", "args": {...}}
+        """
+        # Format 1: tool_call + arguments
+        if "tool_call" in data and isinstance(data["tool_call"], str):
             return {
-                "tool_name": "search_events",
-                "arguments": {"query": llm_response[:100]}
+                "tool_name": data["tool_call"],
+                "arguments": data.get("arguments", {})
             }
         
-        # Check for event details intent
-        if "get_event_details" in response_lower or "chi tiết sự kiện" in response_lower:
-            # Try to extract event_id
-            # Simple extraction - in production use better parsing
-            return None  # Skip for now
+        # Format 2: function + parameters
+        if "function" in data:
+            return {
+                "tool_name": data["function"],
+                "arguments": data.get("parameters", data.get("arguments", {}))
+            }
         
-        # Try to parse JSON if present
-        try:
-            if "{" in llm_response and "}" in llm_response:
-                json_start = llm_response.find("{")
-                json_end = llm_response.rfind("}") + 1
-                json_str = llm_response[json_start:json_end]
-                data = json.loads(json_str)
-                
-                # Check if it's a tool call
-                if "tool_name" in data or "function" in data:
-                    return {
-                        "tool_name": data.get("tool_name") or data.get("function"),
-                        "arguments": data.get("arguments", {})
-                    }
-        except:
-            pass
+        # Format 3: name + args
+        if "name" in data:
+            return {
+                "tool_name": data["name"],
+                "arguments": data.get("args", data.get("arguments", {}))
+            }
+        
+        # Format 4: Direct tool name as key
+        valid_tools = ["search_events", "get_event_details", "get_purchased_events", "save_feedback", "save_lead"]
+        for tool in valid_tools:
+            if tool in data:
+                return {
+                    "tool_name": tool,
+                    "arguments": data[tool] if isinstance(data[tool], dict) else {}
+                }
         
         return None