PraisonAI 3.0.0__py3-none-any.whl

praisonai/cli/features/observability.py

@@ -0,0 +1,293 @@
+"""
+Observability CLI Handler
+
+CLI commands for managing observability providers.
+Usage: praisonai obs <command>
+"""
+
+import os
+from typing import Any, Dict, List, Optional, Tuple
+
+from .base import FlagHandler
+
+
+class ObservabilityHandler(FlagHandler):
+    """
+    Handler for observability CLI commands.
+    
+    Commands:
+        praisonai obs list          - List available providers
+        praisonai obs doctor        - Check provider connectivity
+        praisonai obs init <name>   - Initialize a provider
+    """
+    
+    @property
+    def feature_name(self) -> str:
+        return "observability"
+    
+    @property
+    def flag_name(self) -> str:
+        return "obs"
+    
+    @property
+    def flag_help(self) -> str:
+        return "Observability commands (list, doctor, init)"
+    
+    def check_dependencies(self) -> Tuple[bool, str]:
+        """Check if observability module is available."""
+        try:
+            from praisonai_tools.observability import obs
+            return True, ""
+        except ImportError:
+            return False, "Observability requires praisonai-tools. Install with: pip install praisonai-tools"
+    
+    def list_providers(self) -> Dict[str, Any]:
+        """List all available observability providers."""
+        result = {
+            "registered": [],
+            "available": [],
+            "configured": [],
+        }
+        
+        try:
+            from praisonai_tools.observability.manager import ObservabilityManager
+            from praisonai_tools.observability.config import PROVIDER_ENV_KEYS
+            
+            mgr = ObservabilityManager()
+            
+            # Get all registered providers
+            result["registered"] = mgr.list_providers()
+            
+            # Check which have env vars configured
+            for provider, keys in PROVIDER_ENV_KEYS.items():
+                if all(os.getenv(key) for key in keys):
+                    result["configured"].append(provider)
+            
+            # Check which SDKs are available
+            for provider in result["registered"]:
+                try:
+                    mgr._load_provider(provider)
+                    if provider in mgr._providers:
+                        provider_class = mgr._providers[provider]
+                        instance = provider_class()
+                        if instance.is_available():
+                            result["available"].append(provider)
+                except Exception:
+                    pass
+            
+        except ImportError:
+            pass
+        
+        return result
+    
+    def doctor(self, provider: Optional[str] = None) -> Dict[str, Any]:
+        """Run diagnostics on observability setup."""
+        try:
+            from praisonai_tools.observability import obs
+            
+            if provider:
+                obs.init(provider=provider)
+            
+            return obs.doctor()
+            
+        except ImportError:
+            return {
+                "error": "praisonai-tools not installed",
+                "enabled": False,
+            }
+    
+    def init_provider(self, provider: str, **kwargs) -> bool:
+        """Initialize a specific provider."""
+        try:
+            from praisonai_tools.observability import obs
+            return obs.init(provider=provider, **kwargs)
+        except ImportError:
+            return False
+    
+    def execute(self, action: str = "list", **kwargs) -> Any:
+        """
+        Execute observability command.
+        
+        Args:
+            action: Command to execute (list, doctor, init)
+            **kwargs: Additional arguments
+            
+        Returns:
+            Command result
+        """
+        if action == "list":
+            return self._execute_list()
+        elif action == "doctor":
+            return self._execute_doctor(kwargs.get("provider"))
+        elif action == "init":
+            return self._execute_init(kwargs.get("provider"), **kwargs)
+        else:
+            self.print_status(f"Unknown action: {action}", "error")
+            return None
+    
+    def _execute_list(self) -> Dict[str, Any]:
+        """Execute list command."""
+        result = self.list_providers()
+        
+        self.print_status("\n📊 Observability Providers", "info")
+        self.print_status("=" * 40, "info")
+        
+        # Provider status table
+        all_providers = [
+            "agentops", "langfuse", "langsmith", "traceloop",
+            "arize_phoenix", "openlit", "langtrace", "langwatch",
+            "datadog", "mlflow", "opik", "portkey",
+            "braintrust", "maxim", "weave", "neatlogs",
+            "langdb", "atla", "patronus", "truefoundry",
+        ]
+        
+        for provider in all_providers:
+            status_parts = []
+            if provider in result.get("available", []):
+                status_parts.append("✅ SDK")
+            else:
+                status_parts.append("❌ SDK")
+            
+            if provider in result.get("configured", []):
+                status_parts.append("🔑 Keys")
+            else:
+                status_parts.append("⚪ Keys")
+            
+            status = " | ".join(status_parts)
+            self.print_status(f"  {provider:20} {status}", "info")
+        
+        self.print_status("\n✅ = Available  ❌ = Not installed  🔑 = API key configured", "info")
+        
+        return result
+    
+    def _execute_doctor(self, provider: Optional[str] = None) -> Dict[str, Any]:
+        """Execute doctor command."""
+        result = self.doctor(provider)
+        
+        self.print_status("\n🩺 Observability Diagnostics", "info")
+        self.print_status("=" * 40, "info")
+        
+        self.print_status(f"  Enabled: {result.get('enabled', False)}", "info")
+        self.print_status(f"  Provider: {result.get('provider', 'None')}", "info")
+        
+        if result.get("connection_status") is not None:
+            status = "✅" if result["connection_status"] else "❌"
+            self.print_status(f"  Connection: {status} {result.get('connection_message', '')}", "info")
+        
+        if result.get("available_providers"):
+            self.print_status(f"  Available: {', '.join(result['available_providers'])}", "info")
+        
+        return result
+    
+    def _execute_init(self, provider: str, **kwargs) -> bool:
+        """Execute init command."""
+        if not provider:
+            self.print_status("Provider name required. Usage: praisonai obs init <provider>", "error")
+            return False
+        
+        success = self.init_provider(provider, **kwargs)
+        
+        if success:
+            self.print_status(f"✅ {provider} initialized successfully", "success")
+        else:
+            self.print_status(f"❌ Failed to initialize {provider}", "error")
+            self.print_status(f"   Check that {provider} SDK is installed and API keys are set", "info")
+        
+        return success
+    
+    def apply_to_agent_config(self, config: Dict[str, Any], flag_value: Any) -> Dict[str, Any]:
+        """Apply observability to agent config."""
+        if flag_value:
+            try:
+                from praisonai_tools.observability import obs
+                
+                if isinstance(flag_value, str):
+                    obs.init(provider=flag_value)
+                else:
+                    obs.init()
+                
+                self.print_status("📊 Observability enabled", "success")
+            except ImportError:
+                self.print_status("Observability requires praisonai-tools", "warning")
+        
+        return config
+
+
+# Provider environment variable reference
+PROVIDER_SETUP_GUIDE = {
+    "agentops": {
+        "env_vars": ["AGENTOPS_API_KEY"],
+        "install": "pip install agentops",
+        "docs": "https://agentops.ai/",
+    },
+    "langfuse": {
+        "env_vars": ["LANGFUSE_PUBLIC_KEY", "LANGFUSE_SECRET_KEY"],
+        "install": "pip install opentelemetry-sdk opentelemetry-exporter-otlp",
+        "docs": "https://langfuse.com/",
+    },
+    "langsmith": {
+        "env_vars": ["LANGSMITH_API_KEY"],
+        "install": "pip install opentelemetry-sdk opentelemetry-exporter-otlp",
+        "docs": "https://smith.langchain.com/",
+    },
+    "traceloop": {
+        "env_vars": ["TRACELOOP_API_KEY"],
+        "install": "pip install traceloop-sdk",
+        "docs": "https://traceloop.com/",
+    },
+    "arize_phoenix": {
+        "env_vars": ["PHOENIX_API_KEY"],
+        "install": "pip install arize-phoenix openinference-instrumentation",
+        "docs": "https://phoenix.arize.com/",
+    },
+    "openlit": {
+        "env_vars": [],
+        "install": "pip install openlit",
+        "docs": "https://github.com/openlit/openlit",
+    },
+    "langtrace": {
+        "env_vars": ["LANGTRACE_API_KEY"],
+        "install": "pip install langtrace-python-sdk",
+        "docs": "https://langtrace.ai/",
+    },
+    "langwatch": {
+        "env_vars": ["LANGWATCH_API_KEY"],
+        "install": "pip install langwatch",
+        "docs": "https://langwatch.ai/",
+    },
+    "datadog": {
+        "env_vars": ["DD_API_KEY"],
+        "install": "pip install ddtrace",
+        "docs": "https://www.datadoghq.com/product/llm-observability/",
+    },
+    "mlflow": {
+        "env_vars": ["MLFLOW_TRACKING_URI"],
+        "install": "pip install mlflow",
+        "docs": "https://mlflow.org/",
+    },
+    "opik": {
+        "env_vars": ["OPIK_API_KEY"],
+        "install": "pip install opik",
+        "docs": "https://www.comet.com/docs/opik/",
+    },
+    "portkey": {
+        "env_vars": ["PORTKEY_API_KEY"],
+        "install": "pip install portkey-ai",
+        "docs": "https://portkey.ai/",
+    },
+    "braintrust": {
+        "env_vars": ["BRAINTRUST_API_KEY"],
+        "install": "pip install braintrust",
+        "docs": "https://www.braintrust.dev/",
+    },
+    "maxim": {
+        "env_vars": ["MAXIM_API_KEY"],
+        "install": "pip install maxim-py",
+        "docs": "https://getmaxim.ai/",
+    },
+    "weave": {
+        "env_vars": ["WANDB_API_KEY"],
+        "install": "pip install weave",
+        "docs": "https://weave-docs.wandb.ai/",
+    },
+}

praisonai/cli/features/ollama.py

@@ -0,0 +1,361 @@
+"""
+Ollama CLI Handler
+
+CLI support for Ollama provider and Weak-Model-Proof execution.
+"""
+
+import logging
+import os
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class OllamaHandler:
+    """
+    Handler for Ollama CLI commands.
+    
+    Supports:
+    - --provider ollama
+    - --weak-model-proof / --wmp
+    - --ollama-host
+    - --ollama-model
+    """
+    
+    def __init__(
+        self,
+        model: str = "llama3.2:3b",
+        host: Optional[str] = None,
+        weak_model_proof: bool = True,
+        verbose: bool = False,
+        **kwargs
+    ):
+        """
+        Initialize Ollama handler.
+        
+        Args:
+            model: Ollama model name
+            host: Ollama server host
+            weak_model_proof: Enable WMP
+            verbose: Verbose output
+            **kwargs: Additional options
+        """
+        self.model = model
+        self.host = host or os.environ.get("OLLAMA_HOST", "http://localhost:11434")
+        self.weak_model_proof = weak_model_proof
+        self.verbose = verbose
+        self.extra_kwargs = kwargs
+        
+        self._provider = None
+        self._wmp_hooks = None
+    
+    @property
+    def provider(self):
+        """Lazy-load Ollama provider."""
+        if self._provider is None:
+            try:
+                from praisonai.providers import OllamaProvider
+                self._provider = OllamaProvider(
+                    model=self.model,
+                    host=self.host,
+                    weak_model_proof=self.weak_model_proof,
+                    **self.extra_kwargs
+                )
+            except ImportError as e:
+                logger.error(f"Failed to import OllamaProvider: {e}")
+                raise
+        return self._provider
+    
+    @property
+    def wmp_hooks(self):
+        """Lazy-load WMP hooks."""
+        if self._wmp_hooks is None and self.weak_model_proof:
+            try:
+                from praisonai.wmp import WMPHooks, WeakModelProofConfig
+                
+                # Auto-configure based on model
+                config = WeakModelProofConfig.for_ollama(
+                    self._detect_model_size()
+                )
+                
+                self._wmp_hooks = WMPHooks(
+                    config=config,
+                    llm_fn=self._llm_fn,
+                )
+            except ImportError as e:
+                logger.warning(f"WMP not available: {e}")
+                self._wmp_hooks = None
+        return self._wmp_hooks
+    
+    def _detect_model_size(self) -> str:
+        """Detect model size from name."""
+        model_lower = self.model.lower()
+        
+        if any(x in model_lower for x in ["70b", "72b", "65b"]):
+            return "large"
+        elif any(x in model_lower for x in ["13b", "14b", "7b", "8b"]):
+            return "medium"
+        else:
+            return "small"
+    
+    def _llm_fn(self, prompt: str) -> str:
+        """LLM function for WMP."""
+        response = self.provider.chat(prompt)
+        return response.content
+    
+    def chat(
+        self,
+        message: str,
+        system: Optional[str] = None,
+        stream: bool = False,
+    ) -> str:
+        """
+        Send a chat message.
+        
+        Args:
+            message: User message
+            system: System prompt
+            stream: Enable streaming
+            
+        Returns:
+            Response text
+        """
+        if self.weak_model_proof and self.wmp_hooks:
+            # Use WMP execution
+            self.wmp_hooks.on_task_start(message)
+            
+            messages = [{"role": "user", "content": message}]
+            if system:
+                messages.insert(0, {"role": "system", "content": system})
+            
+            enhanced_messages = self.wmp_hooks.on_before_llm_call(messages)
+            
+            # Call Ollama
+            response = self.provider.chat(
+                messages=enhanced_messages,
+                stream=stream,
+            )
+            
+            if stream:
+                # Collect streamed response
+                full_response = ""
+                for chunk in response:
+                    full_response += chunk
+                    if self.verbose:
+                        print(chunk, end="", flush=True)
+                if self.verbose:
+                    print()
+                response_text = full_response
+            else:
+                response_text = response.content
+            
+            # Post-process with WMP
+            response_text = self.wmp_hooks.on_after_llm_call(response_text)
+            
+            return response_text
+        else:
+            # Direct Ollama call
+            response = self.provider.chat(
+                messages=message,
+                system=system,
+                stream=stream,
+            )
+            
+            if stream:
+                full_response = ""
+                for chunk in response:
+                    full_response += chunk
+                    if self.verbose:
+                        print(chunk, end="", flush=True)
+                if self.verbose:
+                    print()
+                return full_response
+            else:
+                return response.content
+    
+    def execute(
+        self,
+        task: str,
+        tools: Optional[List] = None,
+    ) -> Dict[str, Any]:
+        """
+        Execute a task with WMP.
+        
+        Args:
+            task: Task description
+            tools: Available tools
+            
+        Returns:
+            Execution result
+        """
+        if self.weak_model_proof:
+            try:
+                from praisonai.wmp import WMPExecutor, WeakModelProofConfig
+                
+                config = WeakModelProofConfig.for_ollama(
+                    self._detect_model_size()
+                )
+                
+                executor = WMPExecutor(config=config)
+                result = executor.execute(
+                    task=task,
+                    llm_fn=self._llm_fn,
+                    tools=tools,
+                )
+                
+                return result.to_dict()
+                
+            except ImportError:
+                logger.warning("WMP not available, falling back to direct execution")
+        
+        # Direct execution
+        response = self.chat(task)
+        return {
+            "success": True,
+            "result": response,
+            "wmp_enabled": False,
+        }
+    
+    def list_models(self) -> List[Dict[str, Any]]:
+        """List available Ollama models."""
+        return self.provider.list_models()
+    
+    def pull_model(self, model: str) -> None:
+        """Pull a model from Ollama registry."""
+        if self.verbose:
+            print(f"Pulling model: {model}")
+        
+        for progress in self.provider.pull_model(model, stream=True):
+            if self.verbose and hasattr(progress, 'status'):
+                print(f"  {progress.status}", end="\r")
+        
+        if self.verbose:
+            print(f"\nModel {model} pulled successfully")
+    
+    def is_available(self) -> bool:
+        """Check if Ollama is available."""
+        return self.provider.is_available()
+
+
+def handle_ollama_command(args, unknown_args: List[str] = None) -> int:
+    """
+    Handle Ollama CLI commands.
+    
+    Args:
+        args: Parsed arguments
+        unknown_args: Unknown arguments
+        
+    Returns:
+        Exit code
+    """
+    from rich.console import Console
+    console = Console()
+    
+    # Get options from args
+    model = getattr(args, 'ollama_model', None) or getattr(args, 'model', 'llama3.2:3b')
+    host = getattr(args, 'ollama_host', None)
+    wmp = getattr(args, 'weak_model_proof', True)
+    verbose = getattr(args, 'verbose', False)
+    
+    try:
+        handler = OllamaHandler(
+            model=model,
+            host=host,
+            weak_model_proof=wmp,
+            verbose=verbose,
+        )
+        
+        # Check availability
+        if not handler.is_available():
+            console.print("[red]Error: Ollama server not available[/red]")
+            console.print(f"Make sure Ollama is running at {handler.host}")
+            return 1
+        
+        # Get command/prompt
+        prompt = getattr(args, 'command', None) or getattr(args, 'direct_prompt', None)
+        
+        if not prompt:
+            console.print("[yellow]No prompt provided[/yellow]")
+            return 1
+        
+        # Execute
+        if wmp:
+            console.print(f"[dim]Using Ollama with Weak-Model-Proof ({model})[/dim]")
+        else:
+            console.print(f"[dim]Using Ollama ({model})[/dim]")
+        
+        result = handler.execute(prompt)
+        
+        if result.get("success"):
+            console.print(result.get("result", ""))
+            
+            if verbose and result.get("wmp_enabled"):
+                console.print(f"\n[dim]Steps: {result.get('steps_executed', 0)}, "
+                            f"Retries: {result.get('retries', 0)}[/dim]")
+        else:
+            console.print(f"[red]Error: {result.get('error', 'Unknown error')}[/red]")
+            return 1
+        
+        return 0
+        
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        if verbose:
+            import traceback
+            console.print(traceback.format_exc())
+        return 1
+
+
+def add_ollama_arguments(parser) -> None:
+    """
+    Add Ollama-related arguments to parser.
+    
+    Args:
+        parser: ArgumentParser instance
+    """
+    parser.add_argument(
+        "--provider",
+        type=str,
+        choices=["ollama", "litellm", "openai"],
+        help="LLM provider to use"
+    )
+    parser.add_argument(
+        "--ollama-model",
+        type=str,
+        default="llama3.2:3b",
+        help="Ollama model name (e.g., llama3.2:3b, mistral, qwen2.5:7b)"
+    )
+    parser.add_argument(
+        "--ollama-host",
+        type=str,
+        help="Ollama server host (default: http://localhost:11434)"
+    )
+    parser.add_argument(
+        "--weak-model-proof", "--wmp",
+        action="store_true",
+        default=None,
+        dest="weak_model_proof",
+        help="Enable Weak-Model-Proof execution (default: auto for Ollama)"
+    )
+    parser.add_argument(
+        "--no-wmp",
+        action="store_false",
+        dest="weak_model_proof",
+        help="Disable Weak-Model-Proof execution"
+    )
+    parser.add_argument(
+        "--wmp-strict",
+        action="store_true",
+        help="Use strict WMP mode (more retries, stricter validation)"
+    )
+    parser.add_argument(
+        "--wmp-fast",
+        action="store_true",
+        help="Use fast WMP mode (fewer retries, faster execution)"
+    )
+    parser.add_argument(
+        "--step-budget",
+        type=int,
+        default=10,
+        help="Maximum steps for WMP execution (default: 10)"
+    )