dacp 0.1.0__py3-none-any.whl → 0.3.0__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,28 @@ 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
+
+__version__ = "0.3.0"
 
-__version__ = "0.1.0"
 __all__ = [
-    "register_tool",
-    "run_tool",
-    "TOOL_REGISTRY",
-    "call_llm",
     "parse_agent_response",
     "is_tool_request",
     "get_tool_request",
     "wrap_tool_result",
     "is_final_response",
     "get_final_response",
+    "register_tool",
+    "run_tool",
+    "TOOL_REGISTRY",
+    "file_writer",
+    "call_llm",
+    "invoke_intelligence",
+    "Orchestrator",
+    "Agent",
 ]

dacp/intelligence.py

@@ -0,0 +1,272 @@
+"""
+DACP Intelligence Module - Generic LLM provider interface.
+"""
+
+import os
+import logging
+from typing import Dict, Any, Optional
+
+log = logging.getLogger(__name__)
+
+
+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:
+        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}")
+
+
+def _invoke_openai(prompt: str, config: Dict[str, Any]) -> str:
+    """Invoke OpenAI provider."""
+    try:
+        import openai
+    except ImportError:
+        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)
+    
+    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
+        )
+        
+        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}")
+
+
+def _invoke_anthropic(prompt: str, config: Dict[str, Any]) -> str:
+    """Invoke Anthropic (Claude) provider."""
+    try:
+        import anthropic
+    except ImportError:
+        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)
+    
+    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}]
+        )
+        
+        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}")
+
+
+def _invoke_azure_openai(prompt: str, config: Dict[str, Any]) -> str:
+    """Invoke Azure OpenAI provider."""
+    try:
+        import openai
+    except ImportError:
+        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)
+    
+    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
+        )
+        
+        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 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}")
+
+
+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)
+    
+    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.raise_for_status()
+        
+        result = response.json()
+        
+        # Handle different response formats
+        if "response" in result:
+            return result["response"]  # Ollama format
+        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
+        else:
+            raise IntelligenceError(f"Unexpected response format from local provider: {result}")
+            
+    except requests.RequestException as e:
+        log.error(f"Local provider request error: {e}")
+        raise IntelligenceError(f"Local provider request error: {e}")
+    except Exception as e:
+        log.error(f"Local provider error: {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
+    """
+    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 

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/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()

dacp/orchestrator.py

@@ -0,0 +1,260 @@
+"""
+DACP Orchestrator - Manages agent registration and message routing.
+"""
+
+import logging
+from typing import Dict, Any, Optional, List, Callable
+import uuid
+import json
+from .protocol import (
+    parse_agent_response,
+    is_tool_request,
+    get_tool_request,
+    wrap_tool_result,
+    is_final_response,
+    get_final_response,
+)
+from .tools import run_tool
+
+log = logging.getLogger(__name__)
+
+
+class Agent:
+    """Base agent interface that all agents should implement."""
+    
+    def handle_message(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle incoming messages from the orchestrator."""
+        raise NotImplementedError("Agents must implement handle_message method")
+
+
+class Orchestrator:
+    """
+    Central orchestrator for managing agents and routing messages.
+    Handles agent registration, message routing, and tool execution.
+    """
+    
+    def __init__(self):
+        self.agents: Dict[str, Any] = {}
+        self.conversation_history: List[Dict[str, Any]] = []
+        self.session_id = str(uuid.uuid4())
+        
+    def register_agent(self, agent_id: str, agent: Any) -> None:
+        """
+        Register an agent with the orchestrator.
+        
+        Args:
+            agent_id: Unique identifier for the agent
+            agent: Agent instance that implements handle_message method
+        """
+        if not hasattr(agent, 'handle_message'):
+            raise ValueError(f"Agent {agent_id} must implement handle_message method")
+        
+        self.agents[agent_id] = agent
+        log.info(f"Registered agent: {agent_id}")
+        
+    def unregister_agent(self, agent_id: str) -> bool:
+        """
+        Unregister an agent from the orchestrator.
+        
+        Args:
+            agent_id: ID of the agent to unregister
+            
+        Returns:
+            True if agent was found and removed, False otherwise
+        """
+        if agent_id in self.agents:
+            del self.agents[agent_id]
+            log.info(f"Unregistered agent: {agent_id}")
+            return True
+        return False
+        
+    def get_agent(self, agent_id: str) -> Optional[Any]:
+        """Get an agent by ID."""
+        return self.agents.get(agent_id)
+        
+    def list_agents(self) -> List[str]:
+        """Get list of registered agent IDs."""
+        return list(self.agents.keys())
+        
+    def send_message(self, agent_id: str, message: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Send a message to a specific agent.
+        
+        Args:
+            agent_id: ID of the target agent
+            message: Message to send
+            
+        Returns:
+            Response from the agent
+            
+        Raises:
+            ValueError: If agent_id is not found
+        """
+        if agent_id not in self.agents:
+            raise ValueError(f"Agent {agent_id} not found")
+            
+        agent = self.agents[agent_id]
+        
+        # Add metadata to message
+        enriched_message = {
+            "session_id": self.session_id,
+            "timestamp": self._get_timestamp(),
+            **message
+        }
+        
+        try:
+            # Send message to agent
+            response = agent.handle_message(enriched_message)
+            
+            # Log the interaction
+            self.conversation_history.append({
+                "type": "message",
+                "agent_id": agent_id,
+                "message": enriched_message,
+                "response": response,
+                "timestamp": self._get_timestamp()
+            })
+            
+            return response
+            
+        except Exception as e:
+            error_response = {
+                "error": f"Agent {agent_id} failed to handle message: {str(e)}",
+                "agent_id": agent_id
+            }
+            log.error(f"Error sending message to agent {agent_id}: {e}")
+            return error_response
+            
+    def broadcast_message(self, message: Dict[str, Any], exclude_agents: List[str] = None) -> Dict[str, Dict[str, Any]]:
+        """
+        Broadcast a message to all registered agents.
+        
+        Args:
+            message: Message to broadcast
+            exclude_agents: List of agent IDs to exclude from broadcast
+            
+        Returns:
+            Dictionary mapping agent_id to response
+        """
+        exclude_agents = exclude_agents or []
+        responses = {}
+        
+        for agent_id in self.agents:
+            if agent_id not in exclude_agents:
+                try:
+                    responses[agent_id] = self.send_message(agent_id, message)
+                except Exception as e:
+                    responses[agent_id] = {"error": str(e)}
+                    
+        return responses
+        
+    def handle_tool_request(self, tool_name: str, args: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Handle a tool execution request.
+        
+        Args:
+            tool_name: Name of the tool to execute
+            args: Arguments for the tool
+            
+        Returns:
+            Tool execution result wrapped in protocol format
+        """
+        try:
+            result = run_tool(tool_name, args)
+            return wrap_tool_result(tool_name, result)
+        except Exception as e:
+            error_result = {
+                "success": False,
+                "error": str(e),
+                "tool_name": tool_name,
+                "args": args
+            }
+            return wrap_tool_result(tool_name, error_result)
+            
+    def process_agent_response(self, agent_id: str, response: Any) -> Dict[str, Any]:
+        """
+        Process an agent response, handling tool requests and final responses.
+        
+        Args:
+            agent_id: ID of the agent that sent the response
+            response: Agent response (string or dict)
+            
+        Returns:
+            Processed response
+        """
+        try:
+            # Parse the agent response
+            parsed_response = parse_agent_response(response)
+            
+            # Check if it's a tool request
+            if is_tool_request(parsed_response):
+                tool_name, args = get_tool_request(parsed_response)
+                log.info(f"Agent {agent_id} requested tool: {tool_name}")
+                
+                # Execute the tool
+                tool_result = self.handle_tool_request(tool_name, args)
+                
+                # Log tool execution
+                self.conversation_history.append({
+                    "type": "tool_execution",
+                    "agent_id": agent_id,
+                    "tool_name": tool_name,
+                    "args": args,
+                    "result": tool_result,
+                    "timestamp": self._get_timestamp()
+                })
+                
+                return tool_result
+                
+            # Check if it's a final response
+            elif is_final_response(parsed_response):
+                final_response = get_final_response(parsed_response)
+                log.info(f"Agent {agent_id} sent final response")
+                return final_response
+                
+            else:
+                # Return the parsed response as-is
+                return parsed_response
+                
+        except Exception as e:
+            log.error(f"Error processing agent response from {agent_id}: {e}")
+            return {
+                "error": f"Failed to process response: {str(e)}",
+                "original_response": response
+            }
+            
+    def get_conversation_history(self, agent_id: str = None) -> List[Dict[str, Any]]:
+        """
+        Get conversation history, optionally filtered by agent.
+        
+        Args:
+            agent_id: Optional agent ID to filter by
+            
+        Returns:
+            List of conversation entries
+        """
+        if agent_id:
+            return [
+                entry for entry in self.conversation_history 
+                if entry.get("agent_id") == agent_id
+            ]
+        return self.conversation_history.copy()
+        
+    def clear_history(self) -> None:
+        """Clear conversation history."""
+        self.conversation_history.clear()
+        log.info("Conversation history cleared")
+        
+    def get_session_info(self) -> Dict[str, Any]:
+        """Get current session information."""
+        return {
+            "session_id": self.session_id,
+            "registered_agents": self.list_agents(),
+            "conversation_length": len(self.conversation_history),
+            "timestamp": self._get_timestamp()
+        }
+        
+    def _get_timestamp(self) -> str:
+        """Get current timestamp in ISO format."""
+        from datetime import datetime
+        return datetime.utcnow().isoformat() + "Z"

dacp/tools.py

@@ -1,4 +1,5 @@
 from typing import Dict, Any, Callable
+from pathlib import Path
 
 TOOL_REGISTRY: Dict[str, Callable[..., Dict[str, Any]]] = {}
 
@@ -12,19 +13,43 @@ def run_tool(tool_id: str, args: Dict[str, Any]) -> Dict[str, Any]:
     """Run a registered tool with the given arguments."""
     if tool_id not in TOOL_REGISTRY:
         raise ValueError(f"Unknown tool: {tool_id}")
+
     tool_func = TOOL_REGISTRY[tool_id]
     return tool_func(**args)
 
 
-# --- Example tool ---
-def file_writer(path: str, content: str) -> dict:
-    # Only allow paths in /tmp or ./output for now!
-    allowed_prefixes = ["./output/", "/tmp/"]
-    if not any(path.startswith(prefix) for prefix in allowed_prefixes):
-        raise ValueError("Path not allowed")
-    with open(path, "w") as f:
-        f.write(content)
-    return {"result": f"Written to {path}"}
-
-
+def file_writer(path: str, content: str) -> Dict[str, Any]:
+    """
+    Write content to a file, creating parent directories if they don't exist.
+
+    Args:
+        path: File path to write to
+        content: Content to write to the file
+
+    Returns:
+        Dict with success status and file path
+    """
+    try:
+        # Create parent directories if they don't exist
+        Path(path).parent.mkdir(parents=True, exist_ok=True)
+
+        # Write the content to the file
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(content)
+
+        return {
+            "success": True,
+            "path": path,
+            "message": f"Successfully wrote {len(content)} characters to {path}",
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "path": path,
+            "error": str(e),
+            "message": f"Failed to write to {path}: {e}",
+        }
+
+
+# Register the built-in file_writer tool
 register_tool("file_writer", file_writer)

dacp-0.3.0.dist-info/METADATA

@@ -0,0 +1,369 @@
+Metadata-Version: 2.4
+Name: dacp
+Version: 0.3.0
+Summary: Declarative Agent Communication Protocol - A protocol for managing LLM/agent communications and tool function calls
+Author-email: Andrew Whitehouse <andrew.whitehouse@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/andrewwhitehouse/dacp
+Project-URL: Repository, https://github.com/andrewwhitehouse/dacp
+Project-URL: Documentation, https://github.com/andrewwhitehouse/dacp#readme
+Project-URL: Issues, https://github.com/andrewwhitehouse/dacp/issues
+Keywords: llm,agent,communication,protocol,ai,ml
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Requires-Dist: pyyaml>=5.4.0
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.18.0; extra == "anthropic"
+Provides-Extra: local
+Requires-Dist: requests>=2.25.0; extra == "local"
+Provides-Extra: all
+Requires-Dist: openai>=1.0.0; extra == "all"
+Requires-Dist: anthropic>=0.18.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: flake8>=4.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: types-requests>=2.25.0; extra == "dev"
+Requires-Dist: types-PyYAML>=6.0.0; extra == "dev"
+Dynamic: license-file
+
+# DACP - Declarative Agent Communication Protocol
+
+A Python library for managing LLM/agent communications and tool function calls following the OAS Open Agent Specification.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+import dacp
+
+# Create an orchestrator to manage agents
+orchestrator = dacp.Orchestrator()
+
+# Create and register an agent
+class MyAgent:
+    def handle_message(self, message):
+        return {"response": f"Hello {message.get('name', 'World')}!"}
+
+agent = MyAgent()
+orchestrator.register_agent("my-agent", agent)
+
+# Send a message to the agent
+response = orchestrator.send_message("my-agent", {"name": "Alice"})
+print(response)  # {"response": "Hello Alice!"}
+
+# Use built-in tools
+result = dacp.file_writer("./output/greeting.txt", "Hello, World!")
+print(result["message"])  # "Successfully wrote 13 characters to ./output/greeting.txt"
+
+# Use intelligence providers (supports multiple LLM providers)
+intelligence_config = {
+    "engine": "anthropic",
+    "model": "claude-3-haiku-20240307",
+    "api_key": "your-api-key"  # or set ANTHROPIC_API_KEY env var
+}
+response = dacp.invoke_intelligence("What is the weather like today?", intelligence_config)
+
+# Or use the legacy call_llm function for OpenAI
+response = dacp.call_llm("What is the weather like today?")
+```
+
+## Features
+
+- **Agent Orchestration**: Central management of multiple agents with message routing
+- **Tool Registry**: Register and manage custom tools for LLM agents
+- **Built-in Tools**: Includes a `file_writer` tool that automatically creates parent directories
+- **LLM Integration**: Built-in support for OpenAI models (extensible)
+- **Protocol Parsing**: Parse and validate agent responses
+- **Tool Execution**: Safe execution of registered tools
+- **Conversation History**: Track and query agent interactions
+- **OAS Compliance**: Follows Open Agent Specification standards
+
+## API Reference
+
+### Orchestrator
+
+- `Orchestrator()`: Create a new orchestrator instance
+- `register_agent(agent_id: str, agent) -> None`: Register an agent
+- `unregister_agent(agent_id: str) -> bool`: Remove an agent
+- `send_message(agent_id: str, message: Dict) -> Dict`: Send message to specific agent
+- `broadcast_message(message: Dict, exclude_agents: List[str] = None) -> Dict`: Send message to all agents
+- `get_conversation_history(agent_id: str = None) -> List[Dict]`: Get conversation history
+- `clear_history() -> None`: Clear conversation history
+- `get_session_info() -> Dict`: Get current session information
+
+### Tools
+
+- `register_tool(tool_id: str, func)`: Register a new tool
+- `run_tool(tool_id: str, args: Dict) -> dict`: Execute a registered tool
+- `TOOL_REGISTRY`: Access the current tool registry
+- `file_writer(path: str, content: str) -> dict`: Write content to file, creating directories automatically
+
+### Intelligence (Multi-Provider LLM Support)
+
+- `invoke_intelligence(prompt: str, config: dict) -> str`: Call any supported LLM provider
+- `validate_config(config: dict) -> bool`: Validate intelligence configuration
+- `get_supported_engines() -> list`: Get list of supported engines
+
+### LLM (Legacy)
+
+- `call_llm(prompt: str, model: str = "gpt-4") -> str`: Call OpenAI (legacy function)
+
+### Protocol
+
+- `parse_agent_response(response: str | dict) -> dict`: Parse agent response
+- `is_tool_request(msg: dict) -> bool`: Check if message is a tool request
+- `get_tool_request(msg: dict) -> tuple[str, dict]`: Extract tool request details
+- `wrap_tool_result(name: str, result: dict) -> dict`: Wrap tool result for agent
+- `is_final_response(msg: dict) -> bool`: Check if message is a final response
+- `get_final_response(msg: dict) -> dict`: Extract final response
+
+## Agent Development
+
+### Creating an Agent
+
+Agents must implement a `handle_message` method:
+
+```python
+import dacp
+
+class GreetingAgent:
+    def handle_message(self, message):
+        name = message.get("name", "World")
+        task = message.get("task")
+        
+        if task == "greet":
+            return {"response": f"Hello, {name}!"}
+        elif task == "farewell":
+            return {"response": f"Goodbye, {name}!"}
+        else:
+            return {"error": f"Unknown task: {task}"}
+
+# Register the agent
+orchestrator = dacp.Orchestrator()
+agent = GreetingAgent()
+orchestrator.register_agent("greeter", agent)
+
+# Use the agent
+response = orchestrator.send_message("greeter", {
+    "task": "greet", 
+    "name": "Alice"
+})
+print(response)  # {"response": "Hello, Alice!"}
+```
+
+### Agent Base Class
+
+You can also inherit from the `Agent` base class:
+
+```python
+import dacp
+
+class MyAgent(dacp.Agent):
+    def handle_message(self, message):
+        return {"processed": message}
+```
+
+### Tool Requests from Agents
+
+Agents can request tool execution by returning properly formatted responses:
+
+```python
+class ToolUsingAgent:
+    def handle_message(self, message):
+        if message.get("task") == "write_file":
+            return {
+                "tool_request": {
+                    "name": "file_writer",
+                    "args": {
+                        "path": "./output/agent_file.txt",
+                        "content": "Hello from agent!"
+                    }
+                }
+            }
+        return {"response": "Task completed"}
+
+# The orchestrator will automatically execute the tool and return results
+orchestrator = dacp.Orchestrator()
+agent = ToolUsingAgent()
+orchestrator.register_agent("file-agent", agent)
+
+response = orchestrator.send_message("file-agent", {"task": "write_file"})
+# Tool will be executed automatically
+```
+
+## Intelligence Configuration
+
+DACP supports multiple LLM providers through the `invoke_intelligence` function. Configure different providers using a configuration dictionary:
+
+### OpenAI
+
+```python
+import dacp
+
+openai_config = {
+    "engine": "openai",
+    "model": "gpt-4",  # or "gpt-3.5-turbo", "gpt-4-turbo", etc.
+    "api_key": "your-openai-key",  # or set OPENAI_API_KEY env var
+    "endpoint": "https://api.openai.com/v1",  # optional, uses default
+    "temperature": 0.7,  # optional, default 0.7
+    "max_tokens": 150   # optional, default 150
+}
+
+response = dacp.invoke_intelligence("Explain quantum computing", openai_config)
+```
+
+### Anthropic (Claude)
+
+```python
+anthropic_config = {
+    "engine": "anthropic", 
+    "model": "claude-3-haiku-20240307",  # or other Claude models
+    "api_key": "your-anthropic-key",  # or set ANTHROPIC_API_KEY env var
+    "endpoint": "https://api.anthropic.com",  # optional, uses default
+    "temperature": 0.7,
+    "max_tokens": 150
+}
+
+response = dacp.invoke_intelligence("Write a poem about AI", anthropic_config)
+```
+
+### Azure OpenAI
+
+```python
+azure_config = {
+    "engine": "azure",
+    "model": "gpt-4",  # Your deployed model name
+    "api_key": "your-azure-key",  # or set AZURE_OPENAI_API_KEY env var  
+    "endpoint": "https://your-resource.openai.azure.com",  # or set AZURE_OPENAI_ENDPOINT env var
+    "api_version": "2024-02-01"  # optional, default provided
+}
+
+response = dacp.invoke_intelligence("Analyze this data", azure_config)
+```
+
+### Local LLMs (Ollama, etc.)
+
+```python
+# For Ollama (default local setup)
+local_config = {
+    "engine": "local",
+    "model": "llama2",  # or any model available in Ollama
+    "endpoint": "http://localhost:11434/api/generate",  # Ollama default
+    "temperature": 0.7,
+    "max_tokens": 150
+}
+
+# For custom local APIs
+custom_local_config = {
+    "engine": "local", 
+    "model": "custom-model",
+    "endpoint": "http://localhost:8080/generate",  # Your API endpoint
+    "temperature": 0.7,
+    "max_tokens": 150
+}
+
+response = dacp.invoke_intelligence("Tell me a story", local_config)
+```
+
+### Configuration from OAS YAML
+
+You can load configuration from OAS (Open Agent Specification) YAML files:
+
+```python
+import yaml
+import dacp
+
+# Load config from YAML file
+with open('agent_config.yaml', 'r') as f:
+    config = yaml.safe_load(f)
+
+intelligence_config = config.get('intelligence', {})
+response = dacp.invoke_intelligence("Hello, AI!", intelligence_config)
+```
+
+### Installation for Different Providers
+
+Install optional dependencies for the providers you need:
+
+```bash
+# For OpenAI
+pip install dacp[openai]
+
+# For Anthropic  
+pip install dacp[anthropic]
+
+# For all providers
+pip install dacp[all]
+
+# For local providers (requests is already included in base install)
+pip install dacp[local]
+```
+
+## Built-in Tools
+
+### file_writer
+
+The `file_writer` tool automatically creates parent directories and writes content to files:
+
+```python
+import dacp
+
+# This will create the ./output/ directory if it doesn't exist
+result = dacp.file_writer("./output/file.txt", "Hello, World!")
+
+if result["success"]:
+    print(f"File written: {result['path']}")
+    print(f"Message: {result['message']}")
+else:
+    print(f"Error: {result['error']}")
+```
+
+**Features:**
+- ✅ Automatically creates parent directories
+- ✅ Handles Unicode content properly
+- ✅ Returns detailed success/error information
+- ✅ Safe error handling
+
+## Development
+
+```bash
+# Install development dependencies
+pip install -e .[dev]
+
+# Run tests
+pytest
+
+# Format code
+black .
+
+# Lint code
+flake8
+```
+
+## License
+
+MIT License

dacp-0.3.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+dacp/__init__.py,sha256=-EFiHyOWg8IcG2FI-Hmd9wrHicGi8qAMv0cPwz0oCiU,833
+dacp/exceptions.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dacp/intelligence.py,sha256=SGLaq6dlJmeDqP0ZgT6bR_4WahNf-K7qWBaTG3yqBMI,9487
+dacp/llm.py,sha256=JxHqM-aIm9pAMcVHQevbJGxrlBH4uV1ngRQdvyp9L3A,827
+dacp/main.py,sha256=ZcJLymC9S5A4iO4yV7X178RLlhDrDuAwirdevUD5Yn0,470
+dacp/orchestrator.py,sha256=PIur8Kts-vtUchmo7E8B59ZLm6s7C7yQ0ScK9E5FXhE,8756
+dacp/protocol.py,sha256=DVhLTdyDVlAu8ETSEX8trPeycKfMeirHwcWQ8-BY7eA,1026
+dacp/tools.py,sha256=FLgZa5Brni9H3Hyn336k3DGoVxIa_1rFM4WpIRXzVbc,1569
+dacp/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dacp-0.3.0.dist-info/licenses/LICENSE,sha256=tb5kgUYRypHqAy8wlrJUBSYI5l1SBmawSYHmCC-MVW0,1074
+dacp-0.3.0.dist-info/METADATA,sha256=J9bKw2rxID--1fqZ9Z33lSs2SKTmat72zVLj-DUirU0,11220
+dacp-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dacp-0.3.0.dist-info/top_level.txt,sha256=Qxy0cy5jl7ttTQoGFlY9LXB6CbSvsekJ2y0P8I7L1zA,5
+dacp-0.3.0.dist-info/RECORD,,

dacp-0.1.0.dist-info/METADATA

@@ -1,114 +0,0 @@
-Metadata-Version: 2.4
-Name: dacp
-Version: 0.1.0
-Summary: DACP - Declarative Agent Communication Protocol for LLM/agent communications and tool function calls
-Author-email: Your Name <your.email@example.com>
-License: MIT
-Project-URL: Homepage, https://github.com/yourusername/dacp
-Project-URL: Repository, https://github.com/yourusername/dacp
-Project-URL: Issues, https://github.com/yourusername/dacp/issues
-Keywords: llm,agent,tools,openai,communication
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: openai>=1.0.0
-Provides-Extra: dev
-Requires-Dist: pytest>=7.0.0; extra == "dev"
-Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
-Requires-Dist: black>=22.0.0; extra == "dev"
-Requires-Dist: flake8>=5.0.0; extra == "dev"
-Requires-Dist: mypy>=1.0.0; extra == "dev"
-Requires-Dist: types-requests>=2.28.0; extra == "dev"
-Dynamic: license-file
-
-# DACP - Delcarative Agent Communication Protocol
-
-A Python library for managing LLM/agent communications and tool function calls following the OAS Open Agent Specification.
-
-## Installation
-
-```bash
-pip install -e .
-```
-
-## Quick Start
-
-```python
-import dacp
-
-# Register a custom tool
-def my_custom_tool(param1: str, param2: int) -> dict:
-    return {"result": f"Processed {param1} with {param2}"}
-
-dacp.register_tool("my_custom_tool", my_custom_tool)
-
-# Call an LLM
-response = dacp.call_llm("What is the weather like today?")
-
-# Parse agent response
-parsed = dacp.parse_agent_response(response)
-
-# Check if it's a tool request
-if dacp.is_tool_request(parsed):
-    tool_name, args = dacp.get_tool_request(parsed)
-    result = dacp.run_tool(tool_name, args)
-    tool_response = dacp.wrap_tool_result(tool_name, result)
-```
-
-## Features
-
-- **Tool Registry**: Register and manage custom tools for LLM agents
-- **LLM Integration**: Built-in support for OpenAI models (extensible)
-- **Protocol Parsing**: Parse and validate agent responses
-- **Tool Execution**: Safe execution of registered tools
-- **OAS Compliance**: Follows Open Agent Specification standards
-
-## API Reference
-
-### Tools
-
-- `register_tool(tool_id: str, func)`: Register a new tool
-- `run_tool(tool_id: str, args: Dict) -> dict`: Execute a registered tool
-- `TOOL_REGISTRY`: Access the current tool registry
-
-### LLM
-
-- `call_llm(prompt: str, model: str = "gpt-4") -> str`: Call an LLM with a prompt
-
-### Protocol
-
-- `parse_agent_response(response: str | dict) -> dict`: Parse agent response
-- `is_tool_request(msg: dict) -> bool`: Check if message is a tool request
-- `get_tool_request(msg: dict) -> tuple[str, dict]`: Extract tool request details
-- `wrap_tool_result(name: str, result: dict) -> dict`: Wrap tool result for agent
-- `is_final_response(msg: dict) -> bool`: Check if message is a final response
-- `get_final_response(msg: dict) -> dict`: Extract final response
-
-## Development
-
-```bash
-# Install development dependencies
-pip install -e .[dev]
-
-# Run tests
-pytest
-
-# Format code
-black .
-
-# Lint code
-flake8
-```
-
-## License
-
-MIT License

dacp-0.1.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-dacp/__init__.py,sha256=SY-MnntwhtBTXfVVSSEtK6rLBrlOMkWyXhfPvpeJSDo,690
-dacp/exceptions.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dacp/llm.py,sha256=doz7mHby2pLf0khX-AVcNo9DE1yZCGLwAzaEUEfTeo0,581
-dacp/protocol.py,sha256=DVhLTdyDVlAu8ETSEX8trPeycKfMeirHwcWQ8-BY7eA,1026
-dacp/tools.py,sha256=fkRAnVPgbsOxfphYgevDmrxfIkSF3lliVWAMLThpY68,971
-dacp/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dacp-0.1.0.dist-info/licenses/LICENSE,sha256=tb5kgUYRypHqAy8wlrJUBSYI5l1SBmawSYHmCC-MVW0,1074
-dacp-0.1.0.dist-info/METADATA,sha256=Dwm_o_IWbwSdr3QeRFTccyGzwAwNRRQ20eG8g0BX12I,3447
-dacp-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dacp-0.1.0.dist-info/top_level.txt,sha256=Qxy0cy5jl7ttTQoGFlY9LXB6CbSvsekJ2y0P8I7L1zA,5
-dacp-0.1.0.dist-info/RECORD,,