Update app.py

app.py

@@ -32,8 +32,8 @@ class MCPClientWrapper:
             
             # Make a small test request to validate the key
             test_response = test_client.messages.create(
-                model="claude-sonnet-4-20250514",
-                max_tokens=1000,
+                model="claude-3-5-sonnet-20241022",  # Use consistent model name
+                max_tokens=10,
                 messages=[{"role": "user", "content": "Hi"}]
             )
             
@@ -55,7 +55,6 @@ class MCPClientWrapper:
         if not self.anthropic:
             return "❌ Please set your Anthropic API key first"
         
-        
         if not server_url or not server_url.strip():
             return "❌ Please provide a valid server URL"
         
@@ -90,6 +89,63 @@ class MCPClientWrapper:
             self.tools = []
             self.current_server_url = None
     
+    def _convert_mcp_tool_to_anthropic(self, tool) -> Dict[str, Any]:
+        """Convert MCP tool to Anthropic API format"""
+        tool_def = {
+            "name": tool.name,
+            "description": tool.description or f"Execute {tool.name} tool"
+        }
+        
+        # Handle input schema - ensure it's proper JSON Schema
+        if hasattr(tool, 'input_schema') and tool.input_schema:
+            input_schema = tool.input_schema
+            # Ensure it has required JSON Schema fields
+            if isinstance(input_schema, dict):
+                if "type" not in input_schema:
+                    input_schema["type"] = "object"
+                if "properties" not in input_schema and input_schema["type"] == "object":
+                    input_schema["properties"] = {}
+                tool_def["input_schema"] = input_schema
+            else:
+                # Fallback schema
+                tool_def["input_schema"] = {
+                    "type": "object",
+                    "properties": {},
+                    "additionalProperties": True
+                }
+        else:
+            # Default schema for tools without input schema
+            tool_def["input_schema"] = {
+                "type": "object",
+                "properties": {},
+                "additionalProperties": True
+            }
+        
+        return tool_def
+    
+    def _ensure_message_alternation(self, messages: List[Dict[str, str]]) -> List[Dict[str, str]]:
+        """Ensure proper user/assistant alternation in messages"""
+        if not messages:
+            return messages
+        
+        fixed_messages = []
+        last_role = None
+        
+        for msg in messages:
+            current_role = msg.get("role")
+            if current_role == last_role:
+                # Skip duplicate consecutive roles
+                continue
+            if current_role in ["user", "assistant"]:
+                fixed_messages.append(msg)
+                last_role = current_role
+        
+        # Ensure it starts with user message
+        if fixed_messages and fixed_messages[0]["role"] != "user":
+            fixed_messages = fixed_messages[1:]
+        
+        return fixed_messages
+    
     def process_message(self, message: str, history: List[Union[Dict[str, Any], ChatMessage]]) -> tuple:
         if not self.anthropic:
             return history + [
@@ -104,7 +160,7 @@ class MCPClientWrapper:
             ], gr.Textbox(value="")
         
         try:
-            # Convert history to Claude format
+            # Convert history to Claude format - only include text messages for API
             claude_messages = []
             for msg in history:
                 if isinstance(msg, ChatMessage):
@@ -112,31 +168,48 @@ class MCPClientWrapper:
                 else:
                     role, content = msg.get("role"), msg.get("content")
                 
-                if role in ["user", "assistant", "system"]:
-                    claude_messages.append({"role": role, "content": content})
+                # Only include user/assistant messages, skip metadata-heavy messages
+                if role in ["user", "assistant"] and content and not content.startswith("I'll use the"):
+                    # Skip tool execution messages
+                    if not (isinstance(msg, dict) and msg.get("metadata")):
+                        claude_messages.append({"role": role, "content": content})
             
+            # Add current user message
             claude_messages.append({"role": "user", "content": message})
             
+            # Ensure proper message alternation
+            claude_messages = self._ensure_message_alternation(claude_messages)
+            
             # Convert tools to Claude format
             claude_tools = []
-            for tool in self.tools:
-                if hasattr(tool, 'name') and hasattr(tool, 'description'):
-                    claude_tools.append({
-                        "name": tool.name,
-                        "description": tool.description,
-                        "input_schema": getattr(tool, 'input_schema', {})
-                    })
+            if self.tools:
+                for tool in self.tools:
+                    if hasattr(tool, 'name'):
+                        try:
+                            claude_tool = self._convert_mcp_tool_to_anthropic(tool)
+                            claude_tools.append(claude_tool)
+                        except Exception as e:
+                            print(f"Warning: Failed to convert tool {tool.name}: {e}")
+            
+            print(f"Debug - Sending to API:")
+            print(f"Messages: {json.dumps(claude_messages, indent=2)}")
+            print(f"Tools: {json.dumps(claude_tools, indent=2) if claude_tools else 'None'}")
             
             # Get response from Claude
-            response = self.anthropic.messages.create(
-                model="claude-3-5-sonnet-20241022",
-                max_tokens=1000,
-                messages=claude_messages,
-                tools=claude_tools if claude_tools else None
-            )
+            api_params = {
+                "model": "claude-3-5-sonnet-20241022",
+                "max_tokens": 2000,
+                "messages": claude_messages
+            }
+            
+            if claude_tools:
+                api_params["tools"] = claude_tools
+            
+            response = self.anthropic.messages.create(**api_params)
             
             result_messages = []
             
+            # Process response content
             for content in response.content:
                 if content.type == 'text':
                     result_messages.append({
@@ -147,6 +220,7 @@ class MCPClientWrapper:
                 elif content.type == 'tool_use':
                     tool_name = content.name
                     tool_args = content.input
+                    tool_use_id = content.id
                     
                     result_messages.append({
                         "role": "assistant",
@@ -159,16 +233,6 @@ class MCPClientWrapper:
                         }
                     })
                     
-                    result_messages.append({
-                        "role": "assistant",
-                        "content": "```json\n" + json.dumps(tool_args, indent=2, ensure_ascii=True) + "\n```",
-                        "metadata": {
-                            "parent_id": f"tool_call_{tool_name}",
-                            "id": f"params_{tool_name}",
-                            "title": "Tool Parameters"
-                        }
-                    })
-                    
                     # Execute tool using MCP client
                     try:
                         # Find the tool and execute it
@@ -183,12 +247,15 @@ class MCPClientWrapper:
                         else:
                             result_content = f"Tool {tool_name} not found"
                         
-                        if result_messages and "metadata" in result_messages[-2]:
-                            result_messages[-2]["metadata"]["status"] = "done"
+                        # Format result content
+                        if isinstance(result_content, (dict, list)):
+                            formatted_result = json.dumps(result_content, indent=2)
+                        else:
+                            formatted_result = str(result_content)
                         
                         result_messages.append({
                             "role": "assistant",
-                            "content": "Here are the results from the tool:",
+                            "content": f"```json\n{formatted_result}\n```",
                             "metadata": {
                                 "title": f"Tool Result for {tool_name}",
                                 "status": "done",
@@ -196,53 +263,76 @@ class MCPClientWrapper:
                             }
                         })
                         
-                        # Format result content
-                        if isinstance(result_content, (dict, list)):
-                            result_content = json.dumps(result_content, indent=2)
-                        else:
-                            result_content = str(result_content)
+                        # Create proper tool result message for API
+                        claude_messages.append({
+                            "role": "assistant", 
+                            "content": [
+                                {
+                                    "type": "tool_use",
+                                    "id": tool_use_id,
+                                    "name": tool_name,
+                                    "input": tool_args
+                                }
+                            ]
+                        })
                         
-                        result_messages.append({
-                            "role": "assistant",
-                            "content": "```\n" + result_content + "\n```",
-                            "metadata": {
-                                "parent_id": f"result_{tool_name}",
-                                "id": f"raw_result_{tool_name}",
-                                "title": "Raw Output"
-                            }
+                        claude_messages.append({
+                            "role": "user",
+                            "content": [
+                                {
+                                    "type": "tool_result",
+                                    "tool_use_id": tool_use_id,
+                                    "content": str(result_content)
+                                }
+                            ]
                         })
                         
-                        # Get follow-up response from Claude
-                        claude_messages.append({"role": "user", "content": f"Tool result for {tool_name}: {result_content}"})
-                        next_response = self.anthropic.messages.create(
+                        # Get follow-up response from Claude with proper tool result format
+                        follow_up_response = self.anthropic.messages.create(
                             model="claude-3-5-sonnet-20241022",
-                            max_tokens=1000,
+                            max_tokens=2000,
                             messages=claude_messages,
+                            tools=claude_tools if claude_tools else None
                         )
                         
-                        if next_response.content and next_response.content[0].type == 'text':
-                            result_messages.append({
-                                "role": "assistant",
-                                "content": next_response.content[0].text
-                            })
+                        # Add follow-up response
+                        for follow_content in follow_up_response.content:
+                            if follow_content.type == 'text':
+                                result_messages.append({
+                                    "role": "assistant",
+                                    "content": follow_content.text
+                                })
                     
                     except Exception as tool_error:
+                        print(f"Tool execution error: {tool_error}")
                         result_messages.append({
                             "role": "assistant",
-                            "content": f"❌ Error executing tool: {str(tool_error)}",
+                            "content": f"❌ Error executing tool {tool_name}: {str(tool_error)}",
                             "metadata": {
-                                "parent_id": f"result_{tool_name}",
-                                "id": f"error_{tool_name}",
-                                "title": "Tool Error"
+                                "title": "Tool Error",
+                                "status": "error",
+                                "id": f"error_{tool_name}"
                             }
                         })
             
             return history + [{"role": "user", "content": message}] + result_messages, gr.Textbox(value="")
         
         except Exception as e:
+            print(f"API Error: {e}")
+            error_message = str(e)
+            
+            # Provide more specific error messages
+            if "invalid_request_error" in error_message:
+                if "tools" in error_message:
+                    error_message = f"❌ Tool schema error: {error_message}"
+                else:
+                    error_message = f"❌ Invalid request format: {error_message}"
+            elif "authentication_error" in error_message:
+                error_message = "❌ Authentication failed. Please check your API key."
+            
             return history + [
                 {"role": "user", "content": message}, 
-                {"role": "assistant", "content": f"❌ Error processing message: {str(e)}"}
+                {"role": "assistant", "content": error_message}
             ], gr.Textbox(value="")
 
 client = MCPClientWrapper()