Upload 17 files

agent_service.py

@@ -1,15 +1,17 @@
 """
 Agent Service - Central Brain for Sales & Feedback Agents
-Manages LLM conversation loop with tool calling
+Manages LLM conversation loop with native tool calling
 """
 from typing import Dict, Any, List, Optional
 import os
+import json
 from tools_service import ToolsService
 
 
 class AgentService:
     """
     Manages the conversation loop between User -> LLM -> Tools -> Response
+    Uses native tool calling via HuggingFace Inference API
     """
     
     def __init__(
@@ -19,7 +21,7 @@ class AgentService:
         qdrant_service,
         advanced_rag,
         hf_token: str,
-        feedback_tracking=None  # NEW: Optional feedback tracking
+        feedback_tracking=None  # Optional feedback tracking
     ):
         self.tools_service = tools_service
         self.embedding_service = embedding_service
@@ -48,17 +50,110 @@ class AgentService:
         
         return prompts
     
+    def _get_native_tools(self, mode: str = "sales") -> List[Dict]:
+        """
+        Get tools formatted for native tool calling API.
+        Returns OpenAI-compatible tool definitions.
+        """
+        common_tools = [
+            {
+                "type": "function",
+                "function": {
+                    "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')"}
+                        }
+                    }
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "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"]
+                    }
+                }
+            }
+        ]
+        
+        sales_tools = [
+            {
+                "type": "function",
+                "function": {
+                    "name": "save_lead",
+                    "description": "Lưu thông tin khách hàng quan tâm (Lead).",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "email": {"type": "string", "description": "Email address"},
+                            "phone": {"type": "string", "description": "Phone number"},
+                            "interest": {"type": "string", "description": "What they're interested in"}
+                        }
+                    }
+                }
+            }
+        ]
+        
+        feedback_tools = [
+            {
+                "type": "function",
+                "function": {
+                    "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"]
+                    }
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "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"]
+                    }
+                }
+            }
+        ]
+        
+        if mode == "feedback":
+            return common_tools + feedback_tools
+        else:
+            return common_tools + sales_tools
+    
     async def chat(
         self,
         user_message: str,
         conversation_history: List[Dict],
         mode: str = "sales",  # "sales" or "feedback"
         user_id: Optional[str] = None,
-        access_token: Optional[str] = None,  # NEW: For authenticated API calls
+        access_token: Optional[str] = None,  # For authenticated API calls
         max_iterations: int = 3
     ) -> Dict[str, Any]:
         """
-        Main conversation loop
+        Main conversation loop with native tool calling
         
         Args:
             user_message: User's input
@@ -89,9 +184,12 @@ class AgentService:
         if user_id:
             print(f"  - Stored user_id for tools: {user_id}")
         
-        # Select system prompt
+        # Select system prompt (without tool instructions - native tools handle this)
         system_prompt = self._get_system_prompt(mode)
         
+        # Get native tools for this mode
+        tools = self._get_native_tools(mode)
+        
         # Build conversation context
         messages = self._build_messages(system_prompt, conversation_history, user_message)
         
@@ -102,57 +200,75 @@ class AgentService:
         for iteration in range(max_iterations):
             print(f"\n🔄 Iteration {iteration + 1}")
             
-            # Call LLM
-            llm_response = await self._call_llm(messages)
-            print(f"🧠 LLM Response: {llm_response[:200]}...")
-            
-            # Check if LLM wants to call a tool
-            tool_call = self._parse_tool_call(llm_response)
+            # Call LLM with native tools
+            llm_result = await self._call_llm_with_tools(messages, tools)
             
-            if not tool_call:
-                # No tool call -> This is the final response
-                current_response = llm_response
+            # Check if this is a final text response or a tool call
+            if llm_result["type"] == "text":
+                current_response = llm_result["content"]
+                print(f"🧠 LLM Final Response: {current_response[:200]}...")
                 break
             
-            # Execute tool
-            print(f"🔧 Tool Called: {tool_call['tool_name']}")
-            
-            # Auto-inject real user_id for get_purchased_events
-            if tool_call['tool_name'] == 'get_purchased_events' and self.current_user_id:
-                print(f"🔄 Auto-injecting real user_id: {self.current_user_id}")
-                tool_call['arguments']['user_id'] = self.current_user_id
-            
-            tool_result = await self.tools_service.execute_tool(
-                tool_call['tool_name'],
-                tool_call['arguments'],
-                access_token=self.current_access_token  # Pass access_token
-            )
-            
-            # Record tool call
-            tool_calls_made.append({
-                "function": tool_call['tool_name'],
-                "arguments": tool_call['arguments'],
-                "result": tool_result
-            })
-            
-            # Add tool result to conversation
-            messages.append({
-                "role": "assistant",
-                "content": llm_response
-            })
-            messages.append({
-                "role": "system",
-                "content": f"Tool Result:\n{self._format_tool_result({'result': tool_result})}"
-            })
+            elif llm_result["type"] == "tool_calls":
+                # Process each tool call
+                for tool_call in llm_result["tool_calls"]:
+                    tool_name = tool_call["function"]["name"]
+                    arguments = json.loads(tool_call["function"]["arguments"])
+                    
+                    print(f"🔧 Tool Called: {tool_name}")
+                    print(f"   Arguments: {arguments}")
+                    
+                    # Auto-inject real user_id for get_purchased_events
+                    if tool_name == 'get_purchased_events' and self.current_user_id:
+                        print(f"🔄 Auto-injecting real user_id: {self.current_user_id}")
+                        arguments['user_id'] = self.current_user_id
+                    
+                    # Execute tool
+                    tool_result = await self.tools_service.execute_tool(
+                        tool_name,
+                        arguments,
+                        access_token=self.current_access_token
+                    )
+                    
+                    # Record tool call
+                    tool_calls_made.append({
+                        "function": tool_name,
+                        "arguments": arguments,
+                        "result": tool_result
+                    })
+                    
+                    # Handle RAG search specially
+                    if isinstance(tool_result, dict) and tool_result.get("action") == "run_rag_search":
+                        tool_result = await self._execute_rag_search(tool_result["query"])
+                    
+                    # Add assistant's tool call to messages
+                    messages.append({
+                        "role": "assistant",
+                        "content": None,
+                        "tool_calls": [{
+                            "id": tool_call.get("id", f"call_{iteration}"),
+                            "type": "function",
+                            "function": {
+                                "name": tool_name,
+                                "arguments": json.dumps(arguments)
+                            }
+                        }]
+                    })
+                    
+                    # Add tool result to messages
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call.get("id", f"call_{iteration}"),
+                        "content": self._format_tool_result({"result": tool_result})
+                    })
             
-            # If tool returns "run_rag_search", handle it specially
-            if isinstance(tool_result, dict) and tool_result.get("action") == "run_rag_search":
-                rag_results = await self._execute_rag_search(tool_result["query"])
-                messages[-1]["content"] = f"RAG Search Results:\n{rag_results}"
+            elif llm_result["type"] == "error":
+                print(f"⚠️ LLM Error: {llm_result['content']}")
+                current_response = "Xin lỗi, tôi đang gặp chút vấn đề kỹ thuật. Bạn thử lại sau nhé!"
+                break
         
-        # Clean up response
-        final_response = current_response or llm_response
-        final_response = self._clean_response(final_response)
+        # Get final response if we hit max iterations
+        final_response = current_response or "Tôi cần thêm thông tin để hỗ trợ bạn."
         
         return {
             "message": final_response,
@@ -161,116 +277,9 @@ class AgentService:
         }
     
     def _get_system_prompt(self, mode: str) -> str:
-        """Get system prompt for selected mode with tools definition"""
+        """Get system prompt for selected mode (without tool instructions)"""
         prompt_key = f"{mode}_agent" if mode in ["sales", "feedback"] else "sales_agent"
-        base_prompt = self.prompts.get(prompt_key, "")
-
-        # Add tools definition (filtered by mode)
-        tools_definition = self._get_tools_definition(mode)
-
-        return f"{base_prompt}\n\n{tools_definition}"
-
-    def _get_tools_definition(self, mode: str = "sales") -> str:
-        """Get tools definition in text format for prompt, filtered by mode"""
-
-        # Base header
-        header = """
-# 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:
-"""
-
-        # Tools available for ALL modes
-        common_tools = """
-### 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"}}
-```
-
-### 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"}}
-```
-"""
-
-        # Tools ONLY for sales mode
-        sales_only_tools = """
-### 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"}}
-```
-"""
-
-        # Tools ONLY for feedback mode
-        feedback_only_tools = """
-### get_purchased_events
-Check which events the user has attended. MUST call this tool to get REAL data from API.
-Arguments:
-- user_id (string): User ID
-
-Example:
-```json
-{"tool_call": "get_purchased_events", "arguments": {"user_id": "user_123"}}
-```
-
-### 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!"}}
-```
-"""
-
-        # Footer with important notes
-        footer = """
-**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
-- NEVER invent or fabricate data - always use real results from tools
-"""
-
-        # Build tools definition based on mode
-        if mode == "feedback":
-            return header + common_tools + feedback_only_tools + footer
-        else:  # sales mode (default)
-            return header + common_tools + sales_only_tools + footer
+        return self.prompts.get(prompt_key, "")
     
     def _build_messages(
         self,
@@ -289,9 +298,14 @@ Example:
         
         return messages
     
-    async def _call_llm(self, messages: List[Dict]) -> str:
+    async def _call_llm_with_tools(self, messages: List[Dict], tools: List[Dict]) -> Dict:
         """
-        Call HuggingFace LLM directly using chat_completion (conversational)
+        Call HuggingFace LLM with native tool calling support
+        
+        Returns:
+            {"type": "text", "content": "..."} for text responses
+            {"type": "tool_calls", "tool_calls": [...]} for tool call requests
+            {"type": "error", "content": "..."} for errors
         """
         try:
             from huggingface_hub import AsyncInferenceClient
@@ -299,39 +313,47 @@ Example:
             # Create async client
             client = AsyncInferenceClient(token=self.hf_token)
             
-            # Call HF API with chat completion (conversational)
-            response_text = ""
-            async for message in await client.chat_completion(
-                messages=messages,  # Use messages directly
-                model="openai/gpt-oss-20b",  # GPT-OSS 20B
+            # Call HF API with chat completion and native tools
+            response = await client.chat_completion(
+                messages=messages,
+                model="Qwen/Qwen2.5-72B-Instruct",  # Use Qwen which supports tools
                 max_tokens=512,
                 temperature=0.7,
-                stream=True
-            ):
-                if message.choices and message.choices[0].delta.content:
-                    response_text += message.choices[0].delta.content
+                tools=tools,
+                tool_choice="auto"  # Let model decide when to use tools
+            )
+            
+            # Check if the model made tool calls
+            message = response.choices[0].message
             
-            return response_text
+            if message.tool_calls:
+                print(f"🔧 Native tool calls detected: {len(message.tool_calls)}")
+                return {
+                    "type": "tool_calls",
+                    "tool_calls": [
+                        {
+                            "id": tc.id,
+                            "function": {
+                                "name": tc.function.name,
+                                "arguments": tc.function.arguments
+                            }
+                        }
+                        for tc in message.tool_calls
+                    ]
+                }
+            else:
+                # Regular text response
+                return {
+                    "type": "text",
+                    "content": message.content or ""
+                }
+                
         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é!"
-    
-    def _messages_to_prompt(self, messages: List[Dict]) -> str:
-        """Convert messages array to single prompt string"""
-        prompt_parts = []
-        
-        for msg in messages:
-            role = msg["role"]
-            content = msg["content"]
-            
-            if role == "system":
-                prompt_parts.append(f"[SYSTEM]\n{content}\n")
-            elif role == "user":
-                prompt_parts.append(f"[USER]\n{content}\n")
-            elif role == "assistant":
-                prompt_parts.append(f"[ASSISTANT]\n{content}\n")
-        
-        return "\n".join(prompt_parts)
+            return {
+                "type": "error",
+                "content": str(e)
+            }
     
     def _format_tool_result(self, tool_result: Dict) -> str:
         """Format tool result for feeding back to LLM"""
@@ -372,7 +394,7 @@ Example:
             for key, value in result.items():
                 if key not in ["success", "error"]:
                     formatted.append(f"{key}: {value}")
-            return "\n".join(formatted)
+            return "\n".join(formatted) if formatted else json.dumps(result)
         
         return str(result)
     
@@ -408,117 +430,3 @@ Example:
             formatted.append(f"{i}. {text[:100]}... (ID: {event_id})")
         
         return "\n".join(formatted) if formatted else "Không tìm thấy sự kiện phù hợp."
-    
-    def _parse_tool_call(self, llm_response: str) -> Optional[Dict]:
-        """
-        Parse LLM response to detect tool calls using structured JSON
-        
-        Returns:
-            {"tool_name": "...", "arguments": {...}} or None
-        """
-        import json
-        import re
-        
-        # 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
-        
-        # 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
-        
-        return None
-    
-    def _extract_tool_from_json(self, data: dict) -> Optional[Dict]:
-        """
-        Extract tool call information from parsed JSON
-        
-        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": data["tool_call"],
-                "arguments": data.get("arguments", {})
-            }
-        
-        # Format 2: function + parameters
-        if "function" in data:
-            return {
-                "tool_name": data["function"],
-                "arguments": data.get("parameters", data.get("arguments", {}))
-            }
-        
-        # 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
-    
-    def _clean_response(self, response: str) -> str:
-        """Remove JSON artifacts from final response"""
-        # Remove JSON blocks
-        if "```json" in response:
-            response = response.split("```json")[0]
-        if "```" in response:
-            response = response.split("```")[0]
-        
-        # Remove tool call markers
-        if "{" in response and "tool_call" in response:
-            # Find the last natural sentence before JSON
-            lines = response.split("\n")
-            cleaned = []
-            for line in lines:
-                if "{" in line and "tool_call" in line:
-                    break
-                cleaned.append(line)
-            response = "\n".join(cleaned)
-        
-        return response.strip()