dacp 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

dacp/__init__.py

@@ -11,28 +11,47 @@ from .protocol import (
     is_final_response,
     get_final_response,
 )
-from .tools import (
-    register_tool, run_tool, TOOL_REGISTRY, file_writer
-)
+from .tools import register_tool, execute_tool, TOOL_REGISTRY, file_writer
 from .llm import call_llm
 from .intelligence import invoke_intelligence
 from .orchestrator import Orchestrator, Agent
+from .logging_config import (
+    setup_dacp_logging,
+    enable_debug_logging,
+    enable_info_logging,
+    enable_quiet_logging,
+    set_dacp_log_level,
+    disable_dacp_logging,
+    enable_dacp_logging,
+)
 
 __version__ = "0.3.0"
 
 __all__ = [
+    # Protocol functions
     "parse_agent_response",
     "is_tool_request",
     "get_tool_request",
     "wrap_tool_result",
     "is_final_response",
     "get_final_response",
+    # Tool functions
     "register_tool",
-    "run_tool",
+    "execute_tool",
     "TOOL_REGISTRY",
     "file_writer",
+    # LLM functions
     "call_llm",
     "invoke_intelligence",
+    # Agent orchestration
     "Orchestrator",
     "Agent",
+    # Logging configuration
+    "setup_dacp_logging",
+    "enable_debug_logging",
+    "enable_info_logging",
+    "enable_quiet_logging",
+    "set_dacp_log_level",
+    "disable_dacp_logging",
+    "enable_dacp_logging",
 ]

dacp/intelligence.py

@@ -1,272 +1,303 @@
 """
-DACP Intelligence Module - Generic LLM provider interface.
+Intelligence provider integration for DACP.
+
+This module provides a unified interface for calling different LLM providers
+(OpenAI, Anthropic, Azure, Local) with comprehensive error handling and logging.
 """
 
 import os
 import logging
-from typing import Dict, Any, Optional
+import time
+from typing import Dict, Any, Union
 
-log = logging.getLogger(__name__)
+logger = logging.getLogger("dacp.intelligence")
 
 
-class IntelligenceError(Exception):
-    """Base exception for intelligence provider errors."""
-    pass
+def invoke_intelligence(
+    prompt: str, config: Dict[str, Any]
+) -> Union[str, Dict[str, Any]]:
+    """
+    Invoke an intelligence provider with the given prompt and configuration.
 
+    Args:
+        prompt: The input prompt/message to send to the intelligence provider
+        config: Configuration dictionary containing provider settings
 
-class UnsupportedProviderError(IntelligenceError):
-    """Raised when an unsupported intelligence provider is requested."""
-    pass
+    Returns:
+        Response from the intelligence provider (string or dict)
 
+    Raises:
+        ValueError: If configuration is invalid
+        Exception: If the intelligence call fails
+    """
+    start_time = time.time()
 
-class ConfigurationError(IntelligenceError):
-    """Raised when intelligence configuration is invalid."""
-    pass
+    engine = config.get("engine", "").lower()
+    model = config.get("model", "unknown")
 
+    logger.info(f"🧠 Invoking intelligence: engine='{engine}', model='{model}'")
+    logger.debug(f"📋 Prompt: {prompt[:100]}...")
+
+    try:
+        # Validate configuration
+        _validate_config(config)
+
+        # Route to appropriate provider
+        if engine in ["openai", "gpt"]:
+            result = _invoke_openai(prompt, config)
+        elif engine in ["anthropic", "claude"]:
+            result = _invoke_anthropic(prompt, config)
+        elif engine in ["azure", "azure_openai"]:
+            result = _invoke_azure_openai(prompt, config)
+        elif engine in ["local", "ollama"]:
+            result = _invoke_local(prompt, config)
+        else:
+            available_engines = ["openai", "anthropic", "azure", "local"]
+            raise ValueError(
+                f"Unsupported engine: {engine}. "
+                f"Available engines: {available_engines}"
+            )
+
+        duration = time.time() - start_time
+        logger.info(f"✅ Intelligence call completed in {duration:.3f}s")
+        logger.debug(f"📤 Response: {str(result)[:200]}...")
+
+        return result
+
+    except Exception as e:
+        duration = time.time() - start_time
+        logger.error(
+            f"❌ Intelligence call failed after {duration:.3f}s: "
+            f"{type(e).__name__}: {e}"
+        )
+        raise
+
+
+def _validate_config(config: Dict[str, Any]) -> None:
+    """Validate intelligence configuration."""
+    if not isinstance(config, dict):
+        raise ValueError("Configuration must be a dictionary")
 
-def invoke_intelligence(prompt: str, config: Dict[str, Any]) -> str:
-    """
-    Invoke an intelligence provider (LLM) with the given prompt and configuration.
-    
-    Args:
-        prompt: The input prompt to send to the intelligence provider
-        config: Configuration dictionary containing provider details
-        
-    Returns:
-        Response string from the intelligence provider
-        
-    Raises:
-        UnsupportedProviderError: If the provider is not supported
-        ConfigurationError: If the configuration is invalid
-        IntelligenceError: For other provider-specific errors
-    """
     engine = config.get("engine")
     if not engine:
-        raise ConfigurationError("Missing 'engine' in intelligence configuration")
-    
-    engine = engine.lower()
-    
-    if engine == "openai":
-        return _invoke_openai(prompt, config)
-    elif engine == "anthropic":
-        return _invoke_anthropic(prompt, config)
-    elif engine == "azure":
-        return _invoke_azure_openai(prompt, config)
-    elif engine == "local":
-        return _invoke_local(prompt, config)
-    else:
-        raise UnsupportedProviderError(f"Unsupported intelligence engine: {engine}")
+        raise ValueError("Engine must be specified in configuration")
 
 
 def _invoke_openai(prompt: str, config: Dict[str, Any]) -> str:
-    """Invoke OpenAI provider."""
+    """Invoke OpenAI GPT models."""
     try:
         import openai
     except ImportError:
-        raise IntelligenceError("OpenAI package not installed. Run: pip install openai")
-    
-    model = config.get("model", "gpt-4")
+        raise ImportError("OpenAI package not installed. Run: pip install openai")
+
+    # Get API key
     api_key = config.get("api_key") or os.getenv("OPENAI_API_KEY")
-    base_url = config.get("endpoint", "https://api.openai.com/v1")
-    temperature = config.get("temperature", 0.7)
-    max_tokens = config.get("max_tokens", 150)
-    
     if not api_key:
-        raise ConfigurationError("OpenAI API key not found in config or OPENAI_API_KEY environment variable")
-    
-    try:
-        client = openai.OpenAI(api_key=api_key, base_url=base_url)
-        response = client.chat.completions.create(
-            model=model,
-            messages=[{"role": "user", "content": prompt}],
-            temperature=temperature,
-            max_tokens=max_tokens
+        logger.error("❌ OpenAI API key not found")
+        raise ValueError(
+            "OpenAI API key not found in config or OPENAI_API_KEY "
+            "environment variable"
         )
-        
-        content = response.choices[0].message.content
-        if content is None:
-            raise IntelligenceError("OpenAI returned empty response")
-        return content
-        
-    except Exception as e:
-        log.error(f"OpenAI API error: {e}")
-        raise IntelligenceError(f"OpenAI API error: {e}")
+
+    # Configure client
+    base_url = config.get("base_url")
+    if base_url:
+        client = openai.OpenAI(api_key=api_key, base_url=base_url)
+    else:
+        client = openai.OpenAI(api_key=api_key)
+
+    # Prepare request
+    model = config.get("model", "gpt-3.5-turbo")
+    temperature = config.get("temperature", 0.7)
+    max_tokens = config.get("max_tokens", 1000)
+
+    logger.debug(
+        f"🔧 OpenAI config: model={model}, temp={temperature}, "
+        f"max_tokens={max_tokens}"
+    )
+
+    # Make API call
+    response = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": prompt}],
+        temperature=temperature,
+        max_tokens=max_tokens,
+    )
+
+    content = response.choices[0].message.content
+    if content is None:
+        raise ValueError("OpenAI returned empty response")
+
+    return str(content)
 
 
 def _invoke_anthropic(prompt: str, config: Dict[str, Any]) -> str:
-    """Invoke Anthropic (Claude) provider."""
+    """Invoke Anthropic Claude models."""
     try:
         import anthropic
     except ImportError:
-        raise IntelligenceError("Anthropic package not installed. Run: pip install anthropic")
-    
-    model = config.get("model", "claude-3-haiku-20240307")
+        raise ImportError("Anthropic package not installed. Run: pip install anthropic")
+
+    # Get API key
     api_key = config.get("api_key") or os.getenv("ANTHROPIC_API_KEY")
-    base_url = config.get("endpoint", "https://api.anthropic.com")
-    max_tokens = config.get("max_tokens", 150)
-    temperature = config.get("temperature", 0.7)
-    
     if not api_key:
-        raise ConfigurationError("Anthropic API key not found in config or ANTHROPIC_API_KEY environment variable")
-    
-    try:
-        client = anthropic.Anthropic(api_key=api_key, base_url=base_url)
-        response = client.messages.create(
-            model=model,
-            max_tokens=max_tokens,
-            temperature=temperature,
-            messages=[{"role": "user", "content": prompt}]
+        logger.error("❌ Anthropic API key not found")
+        raise ValueError(
+            "Anthropic API key not found in config or ANTHROPIC_API_KEY "
+            "environment variable"
         )
-        
-        if not response.content or len(response.content) == 0:
-            raise IntelligenceError("Anthropic returned empty response")
-        
-        # Anthropic returns a list of content blocks
-        return response.content[0].text
-        
-    except Exception as e:
-        log.error(f"Anthropic API error: {e}")
-        raise IntelligenceError(f"Anthropic API error: {e}")
+
+    # Configure client
+    base_url = config.get("base_url")
+    if base_url:
+        client = anthropic.Anthropic(api_key=api_key, base_url=base_url)
+    else:
+        client = anthropic.Anthropic(api_key=api_key)
+
+    # Prepare request
+    model = config.get("model", "claude-3-haiku-20240307")
+    temperature = config.get("temperature", 0.7)
+    max_tokens = config.get("max_tokens", 1000)
+
+    logger.debug(
+        f"🔧 Anthropic config: model={model}, temp={temperature}, "
+        f"max_tokens={max_tokens}"
+    )
+
+    # Make API call
+    response = client.messages.create(
+        model=model,
+        max_tokens=max_tokens,
+        temperature=temperature,
+        messages=[{"role": "user", "content": prompt}],
+    )
+
+    # Get text from first content block
+    content_block = response.content[0]
+    if hasattr(content_block, "text"):
+        return str(content_block.text)
+    else:
+        raise ValueError("Anthropic returned unexpected response format")
 
 
 def _invoke_azure_openai(prompt: str, config: Dict[str, Any]) -> str:
-    """Invoke Azure OpenAI provider."""
+    """Invoke Azure OpenAI models."""
     try:
         import openai
     except ImportError:
-        raise IntelligenceError("OpenAI package not installed. Run: pip install openai")
-    
-    model = config.get("model", "gpt-4")
+        raise ImportError("OpenAI package not installed. Run: pip install openai")
+
+    # Get required Azure configuration
     api_key = config.get("api_key") or os.getenv("AZURE_OPENAI_API_KEY")
     endpoint = config.get("endpoint") or os.getenv("AZURE_OPENAI_ENDPOINT")
-    api_version = config.get("api_version", "2024-02-01")
-    temperature = config.get("temperature", 0.7)
-    max_tokens = config.get("max_tokens", 150)
-    
+    api_version = config.get("api_version", "2023-12-01-preview")
+
     if not api_key:
-        raise ConfigurationError("Azure OpenAI API key not found in config or AZURE_OPENAI_API_KEY environment variable")
-    
-    if not endpoint:
-        raise ConfigurationError("Azure OpenAI endpoint not found in config or AZURE_OPENAI_ENDPOINT environment variable")
-    
-    try:
-        client = openai.AzureOpenAI(
-            api_key=api_key,
-            azure_endpoint=endpoint,
-            api_version=api_version
+        logger.error("❌ Azure OpenAI API key not found")
+        raise ValueError(
+            "Azure OpenAI API key not found in config or "
+            "AZURE_OPENAI_API_KEY environment variable"
         )
-        
-        response = client.chat.completions.create(
-            model=model,
-            messages=[{"role": "user", "content": prompt}],
-            temperature=temperature,
-            max_tokens=max_tokens
+
+    if not endpoint:
+        logger.error("❌ Azure OpenAI endpoint not found")
+        raise ValueError(
+            "Azure OpenAI endpoint not found in config or "
+            "AZURE_OPENAI_ENDPOINT environment variable"
         )
-        
-        content = response.choices[0].message.content
-        if content is None:
-            raise IntelligenceError("Azure OpenAI returned empty response")
-        return content
-        
-    except Exception as e:
-        log.error(f"Azure OpenAI API error: {e}")
-        raise IntelligenceError(f"Azure OpenAI API error: {e}")
+
+    # Configure Azure client
+    client = openai.AzureOpenAI(
+        api_key=api_key, azure_endpoint=endpoint, api_version=api_version
+    )
+
+    # Prepare request
+    model = config.get("model", config.get("deployment_name", "gpt-35-turbo"))
+    temperature = config.get("temperature", 0.7)
+    max_tokens = config.get("max_tokens", 1000)
+
+    logger.debug(
+        f"🔧 Azure OpenAI config: model={model}, temp={temperature}, "
+        f"max_tokens={max_tokens}"
+    )
+
+    # Make API call
+    response = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": prompt}],
+        temperature=temperature,
+        max_tokens=max_tokens,
+    )
+
+    content = response.choices[0].message.content
+    if content is None:
+        raise ValueError("Azure OpenAI returned empty response")
+
+    return str(content)
 
 
 def _invoke_local(prompt: str, config: Dict[str, Any]) -> str:
-    """Invoke local LLM provider (e.g., Ollama, local API)."""
+    """Invoke local LLM (e.g., Ollama)."""
     import requests
-    
-    endpoint = config.get("endpoint", "http://localhost:11434/api/generate")
+
+    base_url = config.get("base_url", "http://localhost:11434")
     model = config.get("model", "llama2")
-    temperature = config.get("temperature", 0.7)
-    max_tokens = config.get("max_tokens", 150)
-    
+    endpoint = config.get("endpoint", "/api/generate")
+
+    url = f"{base_url.rstrip('/')}{endpoint}"
+
+    logger.debug(f"🔧 Local config: url={url}, model={model}")
+
+    # Prepare request payload
+    payload = {
+        "model": model,
+        "prompt": prompt,
+        "stream": False,
+        "options": {
+            "temperature": config.get("temperature", 0.7),
+            "num_predict": config.get("max_tokens", 1000),
+        },
+    }
+
     try:
-        # Format for Ollama API
-        if "ollama" in endpoint or ":11434" in endpoint:
-            payload = {
-                "model": model,
-                "prompt": prompt,
-                "stream": False,
-                "options": {
-                    "temperature": temperature,
-                    "num_predict": max_tokens
-                }
-            }
-        else:
-            # Generic local API format
-            payload = {
-                "model": model,
-                "prompt": prompt,
-                "temperature": temperature,
-                "max_tokens": max_tokens
-            }
-        
-        response = requests.post(endpoint, json=payload, timeout=30)
+        response = requests.post(url, json=payload, timeout=config.get("timeout", 30))
         response.raise_for_status()
-        
+
         result = response.json()
-        
-        # Handle different response formats
+
+        # Handle different response formats and ensure string return
         if "response" in result:
-            return result["response"]  # Ollama format
+            response_text = result["response"]
+            return str(response_text) if response_text is not None else ""
+        elif "content" in result:
+            content_text = result["content"]
+            return str(content_text) if content_text is not None else ""
         elif "text" in result:
-            return result["text"]      # Generic format
-        elif "choices" in result and len(result["choices"]) > 0:
-            return result["choices"][0].get("text", "")  # OpenAI-compatible format
+            text_content = result["text"]
+            return str(text_content) if text_content is not None else ""
         else:
-            raise IntelligenceError(f"Unexpected response format from local provider: {result}")
-            
+            logger.warning("Unexpected response format from local LLM")
+            return str(result)
+
     except requests.RequestException as e:
-        log.error(f"Local provider request error: {e}")
-        raise IntelligenceError(f"Local provider request error: {e}")
+        logger.error(f"❌ Local LLM request failed: {e}")
+        raise Exception(f"Local LLM request failed: {e}")
     except Exception as e:
-        log.error(f"Local provider error: {e}")
-        raise IntelligenceError(f"Local provider error: {e}")
+        logger.error(f"❌ Local LLM call failed: {e}")
+        raise
 
 
-def get_supported_engines() -> list:
-    """Get list of supported intelligence engines."""
-    return ["openai", "anthropic", "azure", "local"]
+def _mask_sensitive_config(config: Dict[str, Any]) -> Dict[str, Any]:
+    """Mask sensitive information in config for logging."""
+    masked = config.copy()
+    sensitive_keys = ["api_key", "password", "token", "secret"]
 
+    for key in masked:
+        if any(sensitive in key.lower() for sensitive in sensitive_keys):
+            value = masked[key]
+            if isinstance(value, str) and len(value) > 8:
+                masked[key] = f"{value[:4]}...{value[-4:]}"
+            else:
+                masked[key] = "***"
 
-def validate_config(config: Dict[str, Any]) -> bool:
-    """
-    Validate intelligence configuration.
-    
-    Args:
-        config: Configuration dictionary
-        
-    Returns:
-        True if valid
-        
-    Raises:
-        ConfigurationError: If configuration is invalid
-    """
-    if not isinstance(config, dict):
-        raise ConfigurationError("Configuration must be a dictionary")
-    
-    engine = config.get("engine")
-    if not engine:
-        raise ConfigurationError("Missing 'engine' in configuration")
-    
-    if engine.lower() not in get_supported_engines():
-        raise ConfigurationError(f"Unsupported engine: {engine}. Supported engines: {get_supported_engines()}")
-    
-    # Engine-specific validation
-    engine = engine.lower()
-    
-    if engine in ["openai", "azure"]:
-        if not config.get("api_key") and not os.getenv("OPENAI_API_KEY") and not os.getenv("AZURE_OPENAI_API_KEY"):
-            raise ConfigurationError(f"API key required for {engine} engine")
-    
-    elif engine == "anthropic":
-        if not config.get("api_key") and not os.getenv("ANTHROPIC_API_KEY"):
-            raise ConfigurationError("API key required for Anthropic engine")
-    
-    elif engine == "local":
-        if not config.get("endpoint"):
-            config["endpoint"] = "http://localhost:11434/api/generate"  # Default to Ollama
-    
-    return True 
+    return masked

dacp/llm.py

@@ -9,13 +9,13 @@ from .intelligence import invoke_intelligence
 
 def call_llm(prompt: str, model: str = "gpt-4") -> str:
     """
-    Legacy function for calling LLMs. 
+    Legacy function for calling LLMs.
     Maintained for backward compatibility.
-    
+
     Args:
         prompt: The input prompt
         model: The model to use (defaults to gpt-4)
-        
+
     Returns:
         Response from the LLM
     """
@@ -26,7 +26,14 @@ def call_llm(prompt: str, model: str = "gpt-4") -> str:
         "api_key": os.getenv("OPENAI_API_KEY"),
         "endpoint": "https://api.openai.com/v1",
         "temperature": 0.7,
-        "max_tokens": 150
+        "max_tokens": 150,
     }
-    
-    return invoke_intelligence(prompt, config)
+
+    result = invoke_intelligence(prompt, config)
+
+    # Ensure we return a string for backward compatibility
+    if isinstance(result, str):
+        return result
+    else:
+        # If it's a dict (error response), convert to string
+        return str(result.get("error", "Unknown error occurred"))