dacp 0.1.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

dacp/__init__.py

@@ -1,12 +1,8 @@
 """
-DACP - Declarative Agent Communication Protocol
-
-A Python library for managing LLM/agent communications and tool function calls
-following the OAS Open Agent Specification.
+DACP (Declarative Agent Communication Protocol)
+A protocol for managing LLM/agent communications and tool function calls.
 """
 
-from .tools import register_tool, run_tool, TOOL_REGISTRY
-from .llm import call_llm
 from .protocol import (
     parse_agent_response,
     is_tool_request,
@@ -15,17 +11,49 @@ from .protocol import (
     is_final_response,
     get_final_response,
 )
+from .tools import (
+    register_tool, run_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"
 
-__version__ = "0.1.0"
 __all__ = [
-    "register_tool",
-    "run_tool",
-    "TOOL_REGISTRY",
-    "call_llm",
+    # Protocol functions
     "parse_agent_response",
-    "is_tool_request",
+    "is_tool_request", 
     "get_tool_request",
     "wrap_tool_result",
     "is_final_response",
     "get_final_response",
+    # Tool functions
+    "register_tool",
+    "run_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

@@ -0,0 +1,378 @@
+"""
+DACP Intelligence Module - Generic LLM provider interface.
+"""
+
+import os
+import logging
+from typing import Dict, Any, Optional
+
+# Set up logger for this module
+logger = logging.getLogger("dacp.intelligence")
+
+
+class IntelligenceError(Exception):
+    """Base exception for intelligence provider errors."""
+    pass
+
+
+class UnsupportedProviderError(IntelligenceError):
+    """Raised when an unsupported intelligence provider is requested."""
+    pass
+
+
+class ConfigurationError(IntelligenceError):
+    """Raised when intelligence configuration is invalid."""
+    pass
+
+
+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:
+        logger.error("❌ Missing 'engine' in intelligence configuration")
+        raise ConfigurationError("Missing 'engine' in intelligence configuration")
+    
+    engine = engine.lower()
+    model = config.get("model", "default")
+    
+    logger.info(f"🧠 Invoking intelligence: engine='{engine}', model='{model}'")
+    logger.debug(f"📋 Prompt length: {len(prompt)} characters")
+    logger.debug(f"⚙️  Full config: {_sanitize_config_for_logging(config)}")
+    
+    import time
+    start_time = time.time()
+    
+    try:
+        if engine == "openai":
+            result = _invoke_openai(prompt, config)
+        elif engine == "anthropic":
+            result = _invoke_anthropic(prompt, config)
+        elif engine == "azure":
+            result = _invoke_azure_openai(prompt, config)
+        elif engine == "local":
+            result = _invoke_local(prompt, config)
+        else:
+            logger.error(f"❌ Unsupported intelligence engine: {engine}")
+            raise UnsupportedProviderError(f"Unsupported intelligence engine: {engine}")
+        
+        execution_time = time.time() - start_time
+        logger.info(f"✅ Intelligence response received in {execution_time:.3f}s (length: {len(result)} chars)")
+        logger.debug(f"📤 Response preview: {result[:100]}{'...' if len(result) > 100 else ''}")
+        
+        return result
+        
+    except (IntelligenceError, UnsupportedProviderError, ConfigurationError):
+        # Re-raise our own exceptions without modification
+        execution_time = time.time() - start_time
+        logger.error(f"❌ Intelligence call failed after {execution_time:.3f}s")
+        raise
+    except Exception as e:
+        execution_time = time.time() - start_time
+        logger.error(f"❌ Unexpected intelligence error after {execution_time:.3f}s: {type(e).__name__}: {e}")
+        raise IntelligenceError(f"Unexpected error: {e}")
+
+
+def _invoke_openai(prompt: str, config: Dict[str, Any]) -> str:
+    """Invoke OpenAI provider."""
+    logger.debug("🔵 Initializing OpenAI provider")
+    
+    try:
+        import openai
+        logger.debug("✅ OpenAI package imported successfully")
+    except ImportError:
+        logger.error("❌ OpenAI package not installed")
+        raise IntelligenceError("OpenAI package not installed. Run: pip install openai")
+    
+    model = config.get("model", "gpt-4")
+    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)
+    
+    logger.debug(f"🔧 OpenAI config: model={model}, base_url={base_url}, temp={temperature}, max_tokens={max_tokens}")
+    
+    if not api_key:
+        logger.error("❌ OpenAI API key not found")
+        raise ConfigurationError("OpenAI API key not found in config or OPENAI_API_KEY environment variable")
+    
+    try:
+        logger.debug("🔗 Creating OpenAI client")
+        client = openai.OpenAI(api_key=api_key, base_url=base_url)
+        
+        logger.debug("📡 Sending request to OpenAI API")
+        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:
+            logger.error("❌ OpenAI returned empty response")
+            raise IntelligenceError("OpenAI returned empty response")
+        
+        logger.debug(f"✅ OpenAI API call successful")
+        return content
+        
+    except Exception as e:
+        logger.error(f"❌ OpenAI API error: {type(e).__name__}: {e}")
+        raise IntelligenceError(f"OpenAI API error: {e}")
+
+
+def _invoke_anthropic(prompt: str, config: Dict[str, Any]) -> str:
+    """Invoke Anthropic (Claude) provider."""
+    logger.debug("🟣 Initializing Anthropic provider")
+    
+    try:
+        import anthropic
+        logger.debug("✅ Anthropic package imported successfully")
+    except ImportError:
+        logger.error("❌ Anthropic package not installed")
+        raise IntelligenceError("Anthropic package not installed. Run: pip install anthropic")
+    
+    model = config.get("model", "claude-3-haiku-20240307")
+    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)
+    
+    logger.debug(f"🔧 Anthropic config: model={model}, base_url={base_url}, temp={temperature}, max_tokens={max_tokens}")
+    
+    if not api_key:
+        logger.error("❌ Anthropic API key not found")
+        raise ConfigurationError("Anthropic API key not found in config or ANTHROPIC_API_KEY environment variable")
+    
+    try:
+        logger.debug("🔗 Creating Anthropic client")
+        client = anthropic.Anthropic(api_key=api_key, base_url=base_url)
+        
+        logger.debug("📡 Sending request to Anthropic API")
+        response = client.messages.create(
+            model=model,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            messages=[{"role": "user", "content": prompt}]
+        )
+        
+        if not response.content or len(response.content) == 0:
+            logger.error("❌ Anthropic returned empty response")
+            raise IntelligenceError("Anthropic returned empty response")
+        
+        # Anthropic returns a list of content blocks
+        result = response.content[0].text
+        logger.debug(f"✅ Anthropic API call successful")
+        return result
+        
+    except Exception as e:
+        logger.error(f"❌ Anthropic API error: {type(e).__name__}: {e}")
+        raise IntelligenceError(f"Anthropic API error: {e}")
+
+
+def _invoke_azure_openai(prompt: str, config: Dict[str, Any]) -> str:
+    """Invoke Azure OpenAI provider."""
+    logger.debug("🔷 Initializing Azure OpenAI provider")
+    
+    try:
+        import openai
+        logger.debug("✅ OpenAI package imported successfully")
+    except ImportError:
+        logger.error("❌ OpenAI package not installed")
+        raise IntelligenceError("OpenAI package not installed. Run: pip install openai")
+    
+    model = config.get("model", "gpt-4")
+    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)
+    
+    logger.debug(f"🔧 Azure config: model={model}, endpoint={endpoint}, api_version={api_version}, temp={temperature}, max_tokens={max_tokens}")
+    
+    if not api_key:
+        logger.error("❌ Azure OpenAI API key not found")
+        raise ConfigurationError("Azure OpenAI API key not found in config or AZURE_OPENAI_API_KEY environment variable")
+    
+    if not endpoint:
+        logger.error("❌ Azure OpenAI endpoint not found")
+        raise ConfigurationError("Azure OpenAI endpoint not found in config or AZURE_OPENAI_ENDPOINT environment variable")
+    
+    try:
+        logger.debug("🔗 Creating Azure OpenAI client")
+        client = openai.AzureOpenAI(
+            api_key=api_key,
+            azure_endpoint=endpoint,
+            api_version=api_version
+        )
+        
+        logger.debug("📡 Sending request to Azure OpenAI API")
+        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:
+            logger.error("❌ Azure OpenAI returned empty response")
+            raise IntelligenceError("Azure OpenAI returned empty response")
+        
+        logger.debug(f"✅ Azure OpenAI API call successful")
+        return content
+        
+    except Exception as e:
+        logger.error(f"❌ Azure OpenAI API error: {type(e).__name__}: {e}")
+        raise IntelligenceError(f"Azure OpenAI API error: {e}")
+
+
+def _invoke_local(prompt: str, config: Dict[str, Any]) -> str:
+    """Invoke local LLM provider (e.g., Ollama, local API)."""
+    import requests
+    
+    endpoint = config.get("endpoint", "http://localhost:11434/api/generate")
+    model = config.get("model", "llama2")
+    temperature = config.get("temperature", 0.7)
+    max_tokens = config.get("max_tokens", 150)
+    
+    logger.debug(f"🟢 Initializing local provider")
+    logger.debug(f"🔧 Local config: model={model}, endpoint={endpoint}, temp={temperature}, max_tokens={max_tokens}")
+    
+    try:
+        # Format for Ollama API
+        if "ollama" in endpoint or ":11434" in endpoint:
+            logger.debug("📦 Using Ollama API format")
+            payload = {
+                "model": model,
+                "prompt": prompt,
+                "stream": False,
+                "options": {
+                    "temperature": temperature,
+                    "num_predict": max_tokens
+                }
+            }
+        else:
+            logger.debug("📦 Using generic local API format")
+            payload = {
+                "model": model,
+                "prompt": prompt,
+                "temperature": temperature,
+                "max_tokens": max_tokens
+            }
+        
+        logger.debug(f"📡 Sending request to local endpoint: {endpoint}")
+        response = requests.post(endpoint, json=payload, timeout=30)
+        response.raise_for_status()
+        
+        result = response.json()
+        
+        # Handle different response formats
+        if "response" in result:
+            response_text = result["response"]  # Ollama format
+            logger.debug("✅ Local API call successful (Ollama format)")
+        elif "text" in result:
+            response_text = result["text"]      # Generic format
+            logger.debug("✅ Local API call successful (generic format)")
+        elif "choices" in result and len(result["choices"]) > 0:
+            response_text = result["choices"][0].get("text", "")  # OpenAI-compatible format
+            logger.debug("✅ Local API call successful (OpenAI-compatible format)")
+        else:
+            logger.error(f"❌ Unexpected response format from local provider: {result}")
+            raise IntelligenceError(f"Unexpected response format from local provider: {result}")
+        
+        return response_text
+            
+    except requests.RequestException as e:
+        logger.error(f"❌ Local provider request error: {type(e).__name__}: {e}")
+        raise IntelligenceError(f"Local provider request error: {e}")
+    except Exception as e:
+        logger.error(f"❌ Local provider error: {type(e).__name__}: {e}")
+        raise IntelligenceError(f"Local provider error: {e}")
+
+
+def get_supported_engines() -> list:
+    """Get list of supported intelligence engines."""
+    return ["openai", "anthropic", "azure", "local"]
+
+
+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
+    """
+    logger.debug(f"🔍 Validating intelligence configuration")
+    
+    if not isinstance(config, dict):
+        logger.error("❌ Configuration must be a dictionary")
+        raise ConfigurationError("Configuration must be a dictionary")
+    
+    engine = config.get("engine")
+    if not engine:
+        logger.error("❌ Missing 'engine' in configuration")
+        raise ConfigurationError("Missing 'engine' in configuration")
+    
+    if engine.lower() not in get_supported_engines():
+        logger.error(f"❌ Unsupported engine: {engine}")
+        raise ConfigurationError(f"Unsupported engine: {engine}. Supported engines: {get_supported_engines()}")
+    
+    # Engine-specific validation
+    engine = engine.lower()
+    logger.debug(f"🔧 Validating {engine} specific configuration")
+    
+    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"):
+            logger.error(f"❌ API key required for {engine} engine")
+            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"):
+            logger.error("❌ API key required for Anthropic engine")
+            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
+            logger.debug("🔧 Set default endpoint for local engine")
+    
+    logger.debug(f"✅ Configuration validation successful for {engine}")
+    return True
+
+
+def _sanitize_config_for_logging(config: Dict[str, Any]) -> Dict[str, Any]:
+    """Sanitize config for logging by masking sensitive data."""
+    sanitized = config.copy()
+    
+    # Mask sensitive fields
+    sensitive_fields = ['api_key', 'password', 'token', 'secret']
+    for field in sensitive_fields:
+        if field in sanitized and sanitized[field]:
+            # Show first 4 and last 4 characters, mask the rest
+            value = str(sanitized[field])
+            if len(value) > 8:
+                sanitized[field] = f"{value[:4]}...{value[-4:]}"
+            else:
+                sanitized[field] = "***"
+    
+    return sanitized 

dacp/llm.py

@@ -1,19 +1,32 @@
+"""
+Legacy LLM module - Provides backward compatibility for call_llm function.
+Uses the new intelligence module under the hood.
+"""
+
 import os
-import openai
+from .intelligence import invoke_intelligence
 
 
 def call_llm(prompt: str, model: str = "gpt-4") -> str:
-    # Default: OpenAI, can later extend for other LLMs
-    client = openai.OpenAI(
-        api_key=os.getenv("OPENAI_API_KEY"), base_url="https://api.openai.com/v1"
-    )
-    response = client.chat.completions.create(
-        model=model,
-        messages=[{"role": "user", "content": prompt}],
-        temperature=0.7,
-        max_tokens=150,
-    )
-    content = response.choices[0].message.content
-    if content is None:
-        raise ValueError("LLM returned empty response")
-    return content
+    """
+    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
+    """
+    # Create OpenAI config for backward compatibility
+    config = {
+        "engine": "openai",
+        "model": model,
+        "api_key": os.getenv("OPENAI_API_KEY"),
+        "endpoint": "https://api.openai.com/v1",
+        "temperature": 0.7,
+        "max_tokens": 150
+    }
+    
+    return invoke_intelligence(prompt, config)

dacp/logging_config.py

@@ -0,0 +1,128 @@
+"""
+DACP Logging Configuration
+
+Utilities for configuring logging for DACP components.
+"""
+
+import logging
+import sys
+from typing import Optional
+
+
+def setup_dacp_logging(
+    level: str = "INFO",
+    format_style: str = "detailed",
+    include_timestamp: bool = True,
+    log_file: Optional[str] = None
+) -> None:
+    """
+    Set up logging for DACP components.
+    
+    Args:
+        level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        format_style: Log format style ('simple', 'detailed', 'emoji')
+        include_timestamp: Whether to include timestamps in logs
+        log_file: Optional file path to also log to a file
+    """
+    # Define format styles
+    if format_style == "simple":
+        if include_timestamp:
+            log_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        else:
+            log_format = "%(name)s - %(levelname)s - %(message)s"
+    elif format_style == "detailed":
+        if include_timestamp:
+            log_format = "%(asctime)s - %(name)s:%(lineno)d - %(levelname)s - %(message)s"
+        else:
+            log_format = "%(name)s:%(lineno)d - %(levelname)s - %(message)s"
+    elif format_style == "emoji":
+        # Emoji format doesn't include logger name since emojis provide context
+        if include_timestamp:
+            log_format = "%(asctime)s - %(message)s"
+        else:
+            log_format = "%(message)s"
+    else:
+        raise ValueError(f"Unknown format_style: {format_style}")
+    
+    # Configure root logger for DACP components
+    logger = logging.getLogger("dacp")
+    logger.setLevel(getattr(logging, level.upper()))
+    
+    # Remove existing handlers to avoid duplicates
+    for handler in logger.handlers[:]:
+        logger.removeHandler(handler)
+    
+    # Create formatter
+    formatter = logging.Formatter(
+        log_format,
+        datefmt="%Y-%m-%d %H:%M:%S" if include_timestamp else None
+    )
+    
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    
+    # Optional file handler
+    if log_file:
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+    
+    # Prevent propagation to root logger to avoid duplicate messages
+    logger.propagate = False
+    
+    logger.info(f"🚀 DACP logging configured: level={level}, style={format_style}")
+
+
+def set_dacp_log_level(level: str) -> None:
+    """
+    Set the log level for all DACP components.
+    
+    Args:
+        level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+    """
+    logger = logging.getLogger("dacp")
+    logger.setLevel(getattr(logging, level.upper()))
+    logger.info(f"📊 DACP log level changed to {level}")
+
+
+def disable_dacp_logging() -> None:
+    """Disable all DACP logging."""
+    logger = logging.getLogger("dacp")
+    logger.disabled = True
+
+
+def enable_dacp_logging() -> None:
+    """Re-enable DACP logging."""
+    logger = logging.getLogger("dacp")
+    logger.disabled = False
+
+
+def get_dacp_logger(name: str) -> logging.Logger:
+    """
+    Get a logger for a DACP component.
+    
+    Args:
+        name: Logger name (usually __name__)
+        
+    Returns:
+        Configured logger
+    """
+    return logging.getLogger(f"dacp.{name}")
+
+
+# Convenience functions for quick setup
+def enable_debug_logging(log_file: Optional[str] = None) -> None:
+    """Enable debug logging with detailed format."""
+    setup_dacp_logging(level="DEBUG", format_style="detailed", log_file=log_file)
+
+
+def enable_info_logging(log_file: Optional[str] = None) -> None:
+    """Enable info logging with emoji format."""
+    setup_dacp_logging(level="INFO", format_style="emoji", log_file=log_file)
+
+
+def enable_quiet_logging() -> None:
+    """Enable only error and critical logging."""
+    setup_dacp_logging(level="ERROR", format_style="simple", include_timestamp=False) 

dacp/main.py

@@ -0,0 +1,15 @@
+from dacp.orchestrator import Orchestrator
+
+def main():
+    orchestrator = Orchestrator()
+
+    # Agent registers itself with the orchestrator
+    hello_agent = HelloWorldAgent("hello_agent", orchestrator)
+
+    # Orchestrator sends a message to the agent and prints the response
+    input_message = {"name": "Alice"}
+    response = orchestrator.call_agent("hello_agent", input_message)
+    print("Orchestrator received:", response)
+
+if __name__ == "__main__":
+    main()