hanzo-mcp 0.6.10__tar.gz → 0.6.12__tar.gz

{hanzo_mcp-0.6.10 → hanzo_mcp-0.6.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo-mcp
-Version: 0.6.10
+Version: 0.6.12
 Summary: The Zen of Hanzo MCP: One server to rule them all. The ultimate MCP that orchestrates all others.
 Author-email: Hanzo Industries Inc <dev@hanzo.ai>
 License: MIT

hanzo_mcp-0.6.12/hanzo_mcp/__init__.py

@@ -0,0 +1,12 @@
+"""Hanzo MCP - Implementation of Hanzo capabilities using MCP."""
+
+# Configure FastMCP logging globally for stdio transport
+import os
+if os.environ.get("HANZO_MCP_TRANSPORT") == "stdio":
+    try:
+        from fastmcp.utilities.logging import configure_logging
+        configure_logging(level="ERROR")
+    except ImportError:
+        pass
+
+__version__ = "0.6.12"

{hanzo_mcp-0.6.10 → hanzo_mcp-0.6.12}/hanzo_mcp/cli.py

@@ -2,6 +2,7 @@
 
 import argparse
 import json
+import logging
 import os
 import signal
 import sys
@@ -13,13 +14,33 @@ from hanzo_mcp.server import HanzoMCPServer
 
 def main() -> None:
     """Run the CLI for the Hanzo MCP server."""
-    # Set up signal handler to ensure clean exit
-    def signal_handler(signum, frame):
-        print("\nReceived interrupt signal, shutting down...")
-        sys.exit(0)
     
-    signal.signal(signal.SIGINT, signal_handler)
-    signal.signal(signal.SIGTERM, signal_handler)
+    # Pre-parse arguments to check transport type early
+    import sys
+    early_parser = argparse.ArgumentParser(add_help=False)
+    early_parser.add_argument("--transport", choices=["stdio", "sse"], default="stdio")
+    early_args, _ = early_parser.parse_known_args()
+    
+    # Configure logging VERY early based on transport
+    if early_args.transport == "stdio":
+        # Set environment variable for server to detect stdio mode
+        import os
+        os.environ["HANZO_MCP_TRANSPORT"] = "stdio"
+        
+        # For stdio transport, disable ALL logging immediately
+        from fastmcp.utilities.logging import configure_logging
+        # Set to ERROR to suppress INFO/WARNING messages from FastMCP
+        configure_logging(level="ERROR")
+        
+        # Also configure standard logging to ERROR level
+        logging.basicConfig(
+            level=logging.ERROR,  # Only show errors
+            handlers=[]  # No handlers for stdio to prevent protocol corruption
+        )
+        
+        # Redirect stderr to devnull for stdio transport to prevent any output
+        import sys
+        sys.stderr = open(os.devnull, 'w')
     
     parser = argparse.ArgumentParser(
         description="MCP server implementing Hanzo AI capabilities"
@@ -212,6 +233,32 @@ def main() -> None:
         )
         return
 
+    # Get logger
+    logger = logging.getLogger(__name__)
+    
+    # Set up signal handler to ensure clean exit
+    def signal_handler(signum, frame):
+        if transport != "stdio":
+            logger.info("\nReceived interrupt signal, shutting down...")
+        sys.exit(0)
+    
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+    
+    # Configure logging based on transport (stdio already configured early)
+    if transport != "stdio":
+        # For SSE transport, logging is fine
+        log_level_map = {
+            "DEBUG": logging.DEBUG,
+            "INFO": logging.INFO,
+            "WARNING": logging.WARNING,
+            "ERROR": logging.ERROR
+        }
+        logging.basicConfig(
+            level=log_level_map.get(log_level, logging.INFO),
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+
     # If no allowed paths are specified, use the current directory
     if not allowed_paths:
         allowed_paths = [os.getcwd()]
@@ -263,10 +310,11 @@ def main() -> None:
         # Transport will be automatically cast to Literal['stdio', 'sse'] by the server
         server.run(transport=transport)
     except KeyboardInterrupt:
-        print("\nShutting down...")
+        if transport != "stdio":
+            logger.info("\nShutting down...")
         sys.exit(0)
     except Exception as e:
-        print(f"Server error: {e}", file=sys.stderr)
+        logger.error(f"Server error: {e}")
         sys.exit(1)
 
 
@@ -342,27 +390,29 @@ def install_claude_desktop_config(
             existing_config["mcpServers"][name] = config["mcpServers"][name]
             config = existing_config
         except Exception as e:
-            print(f"Error reading existing config: {e}")
-            print("Creating new config file.")
+            logger = logging.getLogger(__name__)
+            logger.error(f"Error reading existing config: {e}")
+            logger.info("Creating new config file.")
 
     # Write the config file
     with open(config_file, mode="w") as f:
         json.dump(config, f, indent=2)
 
-    print(f"Successfully installed {name} in Claude Desktop configuration.")
-    print(f"Config file: {config_file}")
+    logger = logging.getLogger(__name__)
+    logger.info(f"Successfully installed {name} in Claude Desktop configuration.")
+    logger.info(f"Config file: {config_file}")
 
     if allowed_paths:
-        print("\nAllowed paths:")
+        logger.info("\nAllowed paths:")
         for path in allowed_paths:
-            print(f"- {path}")
+            logger.info(f"- {path}")
     else:
-        print(f"\nDefault allowed path: {home}")
+        logger.info(f"\nDefault allowed path: {home}")
 
-    print(
+    logger.info(
         "\nYou can modify allowed paths in the config file directly."
     )
-    print("Restart Claude Desktop for changes to take effect.")
+    logger.info("Restart Claude Desktop for changes to take effect.")
 
 
 if __name__ == "__main__":

{hanzo_mcp-0.6.10 → hanzo_mcp-0.6.12}/hanzo_mcp/cli_enhanced.py

@@ -2,6 +2,7 @@
 
 import argparse
 import json
+import logging
 import os
 import sys
 from pathlib import Path
@@ -344,8 +345,9 @@ def apply_cli_overrides(args: argparse.Namespace) -> Dict[str, Any]:
 
 def list_tools(settings: HanzoMCPSettings) -> None:
     """List all tools and their current status."""
-    print("Hanzo MCP Tools Status:")
-    print("=" * 50)
+    logger = logging.getLogger(__name__)
+    logger.info("Hanzo MCP Tools Status:")
+    logger.info("=" * 50)
     
     categories = {}
     for tool_name, tool_config in TOOL_REGISTRY.items():
@@ -358,14 +360,14 @@ def list_tools(settings: HanzoMCPSettings) -> None:
         categories[category].append((tool_name, status, tool_config.description))
     
     for category, tools in categories.items():
-        print(f"\n{category.upper()} TOOLS:")
-        print("-" * 30)
+        logger.info(f"\n{category.upper()} TOOLS:")
+        logger.info("-" * 30)
         for tool_name, status, description in tools:
-            print(f"  {status} {tool_name:<15} - {description}")
+            logger.info(f"  {status} {tool_name:<15} - {description}")
     
-    print(f"\nTotal: {len(TOOL_REGISTRY)} tools")
+    logger.info(f"\nTotal: {len(TOOL_REGISTRY)} tools")
     enabled_count = len(settings.get_enabled_tools())
-    print(f"Enabled: {enabled_count}, Disabled: {len(TOOL_REGISTRY) - enabled_count}")
+    logger.info(f"Enabled: {enabled_count}, Disabled: {len(TOOL_REGISTRY) - enabled_count}")
 
 
 def main() -> None:
@@ -385,14 +387,15 @@ def main() -> None:
     settings = load_settings(project_dir=project_dir, config_overrides=config_overrides)
 
     # Handle configuration saving
+    logger = logging.getLogger(__name__)
     if hasattr(args, 'save_config') and args.save_config:
         saved_path = save_settings(settings, global_config=True)
-        print(f"Configuration saved to: {saved_path}")
+        logger.info(f"Configuration saved to: {saved_path}")
         return
     
     if hasattr(args, 'save_project_config') and args.save_project_config:
         saved_path = save_settings(settings, global_config=False)
-        print(f"Project configuration saved to: {saved_path}")
+        logger.info(f"Project configuration saved to: {saved_path}")
         return
 
     # Handle installation

{hanzo_mcp-0.6.10 → hanzo_mcp-0.6.12}/hanzo_mcp/config/settings.py

@@ -364,7 +364,9 @@ def load_settings(
                 global_config = json.load(f)
                 settings = _merge_config(settings, global_config)
         except Exception as e:
-            print(f"Warning: Failed to load global config: {e}")
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.warning(f"Failed to load global config: {e}")
     
     # Load project config
     project_config_path = get_project_config_path(project_dir)
@@ -374,7 +376,9 @@ def load_settings(
                 project_config = json.load(f)
                 settings = _merge_config(settings, project_config)
         except Exception as e:
-            print(f"Warning: Failed to load project config: {e}")
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.warning(f"Failed to load project config: {e}")
     
     # Apply CLI overrides
     if config_overrides:

{hanzo_mcp-0.6.10 → hanzo_mcp-0.6.12}/hanzo_mcp/dev_server.py

@@ -1,6 +1,7 @@
 """Development server with hot reload for Hanzo MCP."""
 
 import asyncio
+import logging
 import os
 import sys
 import time
@@ -67,8 +68,9 @@ class MCPReloadHandler(FileSystemEventHandler):
         
         self.last_reload = current_time
         
-        print(f"\n🔄 File changed: {event.src_path}")
-        print("🔄 Reloading MCP server...")
+        logger = logging.getLogger(__name__)
+        logger.info(f"\n🔄 File changed: {event.src_path}")
+        logger.info("🔄 Reloading MCP server...")
         
         self.restart_callback()
 
@@ -133,9 +135,10 @@ class DevServer:
                 self.observer.schedule(handler, path, recursive=True)
         
         self.observer.start()
-        print(f"👀 Watching for changes in: {package_dir}")
+        logger = logging.getLogger(__name__)
+        logger.info(f"👀 Watching for changes in: {package_dir}")
         if self.project_dir:
-            print(f"👀 Also watching: {self.project_dir}")
+            logger.info(f"👀 Also watching: {self.project_dir}")
     
     def stop_file_watcher(self):
         """Stop the file watcher."""
@@ -146,18 +149,20 @@ class DevServer:
     def restart_server(self):
         """Restart the MCP server."""
         # Since MCP servers run in the same process, we need to handle this differently
-        # For now, we'll print a message indicating a restart is needed
-        print("\n⚠️  Server restart required. Please restart the MCP client to reload changes.")
-        print("💡 Tip: In development, consider using the MCP test client for easier reloading.")
+        # For now, we'll log a message indicating a restart is needed
+        logger = logging.getLogger(__name__)
+        logger.warning("\n⚠️  Server restart required. Please restart the MCP client to reload changes.")
+        logger.info("💡 Tip: In development, consider using the MCP test client for easier reloading.")
     
     async def run_async(self, transport: str = "stdio"):
         """Run the development server asynchronously."""
         self.running = True
         
-        print(f"\n🚀 Starting Hanzo MCP in development mode...")
-        print(f"🔧 Hot reload enabled - watching for file changes")
-        print(f"📁 Project: {self.project_dir or 'current directory'}")
-        print(f"🌐 Transport: {transport}\n")
+        logger = logging.getLogger(__name__)
+        logger.info(f"\n🚀 Starting Hanzo MCP in development mode...")
+        logger.info(f"🔧 Hot reload enabled - watching for file changes")
+        logger.info(f"📁 Project: {self.project_dir or 'current directory'}")
+        logger.info(f"🌐 Transport: {transport}\n")
         
         # Start file watcher
         self.start_file_watcher()
@@ -170,11 +175,11 @@ class DevServer:
             server.run(transport=transport)
             
         except KeyboardInterrupt:
-            print("\n\n🛑 Shutting down development server...")
+            logger.info("\n\n🛑 Shutting down development server...")
         finally:
             self.running = False
             self.stop_file_watcher()
-            print("👋 Development server stopped")
+            logger.info("👋 Development server stopped")
     
     def run(self, transport: str = "stdio"):
         """Run the development server."""

{hanzo_mcp-0.6.10 → hanzo_mcp-0.6.12}/hanzo_mcp/server.py

@@ -1,6 +1,7 @@
 """MCP server implementing Hanzo capabilities."""
 
 import atexit
+import logging
 import signal
 import threading
 import time
@@ -154,7 +155,10 @@ class HanzoMCPServer:
         # Register signal handlers for graceful shutdown
         def signal_handler(signum, frame):
             import sys
-            print("\nShutting down gracefully...")
+            # Only log if not stdio transport
+            if hasattr(self, '_transport') and self._transport != 'stdio':
+                logger = logging.getLogger(__name__)
+                logger.info("\nShutting down gracefully...")
             self._cleanup_sessions()
             self._shutdown_event.set()
             sys.exit(0)
@@ -189,7 +193,10 @@ class HanzoMCPServer:
         try:
             cleared_count = SessionStorage.clear_all_sessions()
             if cleared_count > 0:
-                print(f"Cleaned up {cleared_count} tmux sessions on shutdown")
+                # Only log if not stdio transport
+                if hasattr(self, '_transport') and self._transport != 'stdio':
+                    logger = logging.getLogger(__name__)
+                    logger.info(f"Cleaned up {cleared_count} tmux sessions on shutdown")
         except Exception:
             # Ignore cleanup errors during shutdown
             pass
@@ -201,6 +208,9 @@ class HanzoMCPServer:
             transport: The transport to use (stdio or sse)
             allowed_paths: list of paths that the server is allowed to access
         """
+        # Store transport for later use
+        self._transport = transport
+        
         # Add allowed paths if provided
         allowed_paths_list = allowed_paths or []
         for path in allowed_paths_list:

{hanzo_mcp-0.6.10 → hanzo_mcp-0.6.12}/hanzo_mcp/tools/__init__.py

@@ -124,7 +124,9 @@ def register_all_tools(
             )
             # Auto-detect projects from search paths
             detected_projects = project_manager.detect_projects(search_paths)
-            print(f"Detected {len(detected_projects)} projects with LLM.md files")
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.info(f"Detected {len(detected_projects)} projects with LLM.md files")
     
     filesystem_tools = register_filesystem_tools(
         mcp_server, 

{hanzo_mcp-0.6.10 → hanzo_mcp-0.6.12}/hanzo_mcp/tools/shell/bash_session_executor.py

@@ -5,6 +5,7 @@ implementation with the new BashSession-based approach for better persistent exe
 """
 
 import asyncio
+import logging
 import os
 import shlex
 import subprocess
@@ -64,16 +65,18 @@ class BashSessionExecutor:
         if data is not None:
             try:
                 import json
-
+                logger = logging.getLogger(__name__)
                 if isinstance(data, (dict, list)):
                     data_str = json.dumps(data)
                 else:
                     data_str = str(data)
-                print(f"DEBUG: {message}: {data_str}")
+                logger.debug(f"{message}: {data_str}")
             except Exception:
-                print(f"DEBUG: {message}: {data}")
+                logger = logging.getLogger(__name__)
+                logger.debug(f"{message}: {data}")
         else:
-            print(f"DEBUG: {message}")
+            logger = logging.getLogger(__name__)
+            logger.debug(f"{message}")
 
     def allow_command(self, command: str) -> None:
         """Allow a specific command that might otherwise be excluded.

{hanzo_mcp-0.6.10 → hanzo_mcp-0.6.12}/hanzo_mcp/tools/shell/command_executor.py

@@ -183,16 +183,18 @@ class CommandExecutor:
         if data is not None:
             try:
                 import json
-
+                logger = logging.getLogger(__name__)
                 if isinstance(data, (dict, list)):
                     data_str = json.dumps(data)
                 else:
                     data_str = str(data)
-                print(f"DEBUG: {message}: {data_str}", file=sys.stderr)
+                logger.debug(f"{message}: {data_str}")
             except Exception:
-                print(f"DEBUG: {message}: {data}", file=sys.stderr)
+                logger = logging.getLogger(__name__)
+                logger.debug(f"{message}: {data}")
         else:
-            print(f"DEBUG: {message}", file=sys.stderr)
+            logger = logging.getLogger(__name__)
+            logger.debug(f"{message}")
 
     def is_command_allowed(self, command: str) -> bool:
         """Check if a command is allowed based on exclusion lists.

{hanzo_mcp-0.6.10 → hanzo_mcp-0.6.12}/hanzo_mcp/tools/vector/__init__.py

@@ -62,7 +62,9 @@ try:
             # Auto-detect projects from search paths for new manager
             if search_paths:
                 detected_projects = project_manager.detect_projects(search_paths)
-                print(f"Detected {len(detected_projects)} projects with LLM.md files")
+                import logging
+                logger = logging.getLogger(__name__)
+                logger.info(f"Detected {len(detected_projects)} projects with LLM.md files")
         
         # Register individual tools if enabled
         if tool_enabled.get("index", True):
@@ -85,7 +87,9 @@ except ImportError:
     
     def register_vector_tools(*args, **kwargs) -> list[BaseTool]:
         """Vector tools not available - missing dependencies."""
-        print("Warning: Vector tools not available. Install infinity-embedded: pip install infinity-embedded")
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.warning("Vector tools not available. Install infinity-embedded: pip install infinity-embedded")
         return []
 
 

{hanzo_mcp-0.6.10 → hanzo_mcp-0.6.12}/hanzo_mcp/tools/vector/ast_analyzer.py

@@ -94,7 +94,9 @@ class ASTAnalyzer:
                 # Python parser
                 self.parsers['python'] = tree_sitter.Language(tspython.language())
             except Exception as e:
-                print(f"Warning: Could not initialize Python parser: {e}")
+                import logging
+                logger = logging.getLogger(__name__)
+                logger.warning(f"Could not initialize Python parser: {e}")
     
     def analyze_file(self, file_path: str) -> Optional[FileAST]:
         """Analyze a file and extract AST information and symbols.
@@ -127,7 +129,9 @@ class ASTAnalyzer:
                 return self._analyze_generic_file(file_path, content, file_hash, language)
                 
         except Exception as e:
-            print(f"Error analyzing file {file_path}: {e}")
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.error(f"Error analyzing file {file_path}: {e}")
             return None
     
     def _detect_language(self, path: Path) -> Optional[str]:
@@ -194,9 +198,13 @@ class ASTAnalyzer:
                 ast_nodes = self._extract_tree_sitter_nodes(ts_tree.root_node, content)
             
         except SyntaxError as e:
-            print(f"Syntax error in {file_path}: {e}")
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.error(f"Syntax error in {file_path}: {e}")
         except Exception as e:
-            print(f"Error parsing Python file {file_path}: {e}")
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.error(f"Error parsing Python file {file_path}: {e}")
         
         return FileAST(
             file_path=file_path,

{hanzo_mcp-0.6.10 → hanzo_mcp-0.6.12}/hanzo_mcp/tools/vector/infinity_store.py

@@ -528,7 +528,9 @@ class InfinityVectorStore:
             return file_ast
             
         except Exception as e:
-            print(f"Error searching AST nodes: {e}")
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.error(f"Error searching AST nodes: {e}")
             return None
     
     def get_file_references(self, file_path: str) -> List[Dict[str, Any]]:
@@ -555,7 +557,9 @@ class InfinityVectorStore:
             return references
             
         except Exception as e:
-            print(f"Error getting file references: {e}")
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.error(f"Error getting file references: {e}")
             return []
     
     def search(
@@ -803,7 +807,9 @@ class InfinityVectorStore:
             
             return True
         except Exception as e:
-            print(f"Error clearing vector store: {e}")
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.error(f"Error clearing vector store: {e}")
             return False
     
     async def index_document(

{hanzo_mcp-0.6.10 → hanzo_mcp-0.6.12}/hanzo_mcp/tools/vector/project_manager.py

@@ -294,7 +294,9 @@ class ProjectVectorManager:
             project_name = project_names[i]
             if isinstance(result, Exception):
                 # Log error but continue
-                print(f"Error searching project {project_name}: {result}")
+                import logging
+                logger = logging.getLogger(__name__)
+                logger.error(f"Error searching project {project_name}: {result}")
                 combined_results[project_name] = []
             else:
                 combined_results[project_name] = result

{hanzo_mcp-0.6.10 → hanzo_mcp-0.6.12}/hanzo_mcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hanzo-mcp
-Version: 0.6.10
+Version: 0.6.12
 Summary: The Zen of Hanzo MCP: One server to rule them all. The ultimate MCP that orchestrates all others.
 Author-email: Hanzo Industries Inc <dev@hanzo.ai>
 License: MIT

{hanzo_mcp-0.6.10 → hanzo_mcp-0.6.12}/hanzo_mcp.egg-info/SOURCES.txt

@@ -140,7 +140,13 @@ hanzo_mcp/tools/vector/vector_search.py
 tests/test_async_support.py
 tests/test_cli.py
 tests/test_git_ingestion.py
+tests/test_litellm_warnings.py
+tests/test_manual.py
 tests/test_new_tools.py
+tests/test_palette.py
 tests/test_search_quality.py
+tests/test_simple.py
+tests/test_stdio_protocol.py
+tests/test_stdio_simple.py
 tests/test_unified_search.py
 tests/test_vector_store.py

{hanzo_mcp-0.6.10 → hanzo_mcp-0.6.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hanzo-mcp"
-version = "0.6.10"
+version = "0.6.12"
 description = "The Zen of Hanzo MCP: One server to rule them all. The ultimate MCP that orchestrates all others."
 readme = "README.md"
 requires-python = ">=3.12"

hanzo_mcp-0.6.12/tests/test_litellm_warnings.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python
+"""Test that litellm deprecation warnings are properly suppressed."""
+
+import subprocess
+import sys
+import os
+
+
+def test_no_pydantic_warnings():
+    """Test that running uvx hanzo-mcp doesn't show Pydantic deprecation warnings."""
+    # Run the command and capture stderr
+    result = subprocess.run(
+        [sys.executable, "-m", "hanzo_mcp.cli", "--help"],
+        capture_output=True,
+        text=True
+    )
+    
+    # Check for deprecation warnings in stderr
+    assert "PydanticDeprecatedSince20" not in result.stderr, \
+        f"Pydantic deprecation warning found in stderr: {result.stderr}"
+    
+    # Check that the command succeeded
+    assert result.returncode == 0, f"Command failed with return code {result.returncode}"
+    
+    # Check that help text is shown
+    assert "MCP server implementing Hanzo AI capabilities" in result.stdout
+
+
+def test_agent_tool_no_warnings():
+    """Test that importing agent tools doesn't produce warnings."""
+    # Create a test script that imports agent tools
+    test_script = '''
+import warnings
+import sys
+
+# Capture warnings
+with warnings.catch_warnings(record=True) as w:
+    warnings.simplefilter("always")
+    
+    # Import agent tools (which imports litellm)
+    from hanzo_mcp.tools.agent import register_agent_tools
+    
+    # Check for deprecation warnings
+    deprecation_warnings = [warning for warning in w if issubclass(warning.category, DeprecationWarning)]
+    
+    if deprecation_warnings:
+        print("DEPRECATION WARNINGS FOUND:", file=sys.stderr)
+        for warning in deprecation_warnings:
+            print(f"  {warning.category.__name__}: {warning.message}", file=sys.stderr)
+        sys.exit(1)
+    else:
+        print("No deprecation warnings found")
+        sys.exit(0)
+'''
+    
+    # Run the test script
+    result = subprocess.run(
+        [sys.executable, "-c", test_script],
+        capture_output=True,
+        text=True,
+        env={**os.environ, "PYTHONPATH": os.path.dirname(os.path.dirname(__file__))}
+    )
+    
+    # Check that no warnings were found
+    assert result.returncode == 0, f"Deprecation warnings found: {result.stderr}"
+    assert "No deprecation warnings found" in result.stdout
+
+
+if __name__ == "__main__":
+    test_no_pydantic_warnings()
+    test_agent_tool_no_warnings()
+    print("✅ All litellm warning tests passed!")