dacp 0.3.2__tar.gz → 0.3.3__tar.gz

{dacp-0.3.2 → dacp-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dacp
-Version: 0.3.2
+Version: 0.3.3
 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

{dacp-0.3.2 → dacp-0.3.3}/dacp/__init__.py

@@ -24,6 +24,28 @@ from .logging_config import (
     disable_dacp_logging,
     enable_dacp_logging,
 )
+from .json_parser import (
+    robust_json_parse,
+    parse_with_fallback,
+    extract_json_from_text,
+    create_fallback_response,
+)
+from .workflow import (
+    WorkflowOrchestrator,
+    TaskBoard,
+    Task,
+    TaskStatus,
+    TaskPriority,
+    WorkflowRule,
+)
+from .workflow_runtime import (
+    WorkflowRuntime,
+    AgentRegistry,
+    TaskRegistry,
+    TaskExecution,
+    RegisteredAgent,
+    TaskStatus as RuntimeTaskStatus,
+)
 
 __version__ = "0.3.0"
 
@@ -54,4 +76,23 @@ __all__ = [
     "set_dacp_log_level",
     "disable_dacp_logging",
     "enable_dacp_logging",
+    # JSON parsing utilities
+    "robust_json_parse",
+    "parse_with_fallback",
+    "extract_json_from_text",
+    "create_fallback_response",
+    # Workflow management
+    "WorkflowOrchestrator",
+    "TaskBoard",
+    "Task",
+    "TaskStatus",
+    "TaskPriority",
+    "WorkflowRule",
+    # Workflow runtime
+    "WorkflowRuntime",
+    "AgentRegistry",
+    "TaskRegistry",
+    "TaskExecution",
+    "RegisteredAgent",
+    "RuntimeTaskStatus",
 ]

dacp-0.3.3/dacp/json_parser.py

@@ -0,0 +1,232 @@
+"""
+DACP JSON Parser - Robust JSON parsing for agent responses.
+
+This module provides enhanced JSON parsing capabilities that can handle
+various LLM response formats and provide intelligent fallbacks.
+"""
+
+import json
+import re
+import logging
+from typing import Dict, Any, Optional, Union
+from pydantic import BaseModel
+
+logger = logging.getLogger("dacp.json_parser")
+
+
+def extract_json_from_text(text: str) -> Optional[Dict[str, Any]]:
+    """
+    Extract JSON from text using multiple strategies.
+    
+    Args:
+        text: Raw text that might contain JSON
+        
+    Returns:
+        Parsed JSON dict or None if no valid JSON found
+    """
+    if not isinstance(text, str):
+        return None
+    
+    logger.debug(f"🔍 Attempting to extract JSON from text: {text[:100]}...")
+    
+    # Strategy 1: Try parsing the entire text as JSON
+    try:
+        result = json.loads(text.strip())
+        logger.debug("✅ Successfully parsed entire text as JSON")
+        return result
+    except json.JSONDecodeError:
+        logger.debug("❌ Failed to parse entire text as JSON")
+    
+    # Strategy 2: Find JSON between braces
+    json_start = text.find('{')
+    json_end = text.rfind('}') + 1
+    if json_start >= 0 and json_end > json_start:
+        json_str = text[json_start:json_end]
+        try:
+            result = json.loads(json_str)
+            logger.debug("✅ Successfully extracted JSON between braces")
+            return result
+        except json.JSONDecodeError:
+            logger.debug("❌ Failed to parse JSON between braces")
+    
+    # Strategy 3: Find JSON in code blocks
+    code_block_pattern = r'```(?:json)?\s*(\{.*?\})\s*```'
+    matches = re.findall(code_block_pattern, text, re.DOTALL)
+    for match in matches:
+        try:
+            result = json.loads(match)
+            logger.debug("✅ Successfully extracted JSON from code block")
+            return result
+        except json.JSONDecodeError:
+            continue
+    
+    # Strategy 4: Find JSON after common prefixes
+    prefixes = [
+        "json response:",
+        "response:",
+        "output:",
+        "result:",
+        "here is the json:",
+        "the json is:",
+    ]
+    
+    for prefix in prefixes:
+        prefix_pos = text.lower().find(prefix.lower())
+        if prefix_pos >= 0:
+            remaining_text = text[prefix_pos + len(prefix):].strip()
+            extracted = extract_json_from_text(remaining_text)
+            if extracted:
+                logger.debug(f"✅ Successfully extracted JSON after prefix: {prefix}")
+                return extracted
+    
+    logger.debug("❌ No valid JSON found in text")
+    return None
+
+
+def create_fallback_response(
+    text: str, 
+    required_fields: Dict[str, Any],
+    optional_fields: Dict[str, Any] = None
+) -> Dict[str, Any]:
+    """
+    Create a fallback response when JSON parsing fails.
+    
+    Args:
+        text: Original LLM response text
+        required_fields: Dictionary of required field names and default values
+        optional_fields: Dictionary of optional field names and default values
+        
+    Returns:
+        Dictionary with required fields filled
+    """
+    logger.info(f"🔄 Creating fallback response for text: {text[:50]}...")
+    
+    fallback = {}
+    
+    # Fill required fields with defaults or extracted content
+    for field_name, default_value in required_fields.items():
+        if field_name in ["message", "response_message", "greeting_message"]:
+            # Use the original text as the message
+            fallback[field_name] = text.strip()
+            logger.debug(f"📝 Using text as {field_name}")
+        elif field_name in ["agent", "sender_agent", "target_agent"]:
+            # Try to extract agent names or use default
+            agent_match = re.search(r'agent[:\s]+([a-zA-Z0-9_-]+)', text, re.IGNORECASE)
+            if agent_match:
+                fallback[field_name] = agent_match.group(1)
+                logger.debug(f"🎯 Extracted agent name: {agent_match.group(1)}")
+            else:
+                fallback[field_name] = default_value or "unknown"
+                logger.debug(f"🔧 Using default for {field_name}: {fallback[field_name]}")
+        else:
+            fallback[field_name] = default_value
+            logger.debug(f"⚙️ Setting {field_name} to default: {default_value}")
+    
+    # Fill optional fields if provided
+    if optional_fields:
+        for field_name, default_value in optional_fields.items():
+            fallback[field_name] = default_value
+            logger.debug(f"📋 Adding optional field {field_name}: {default_value}")
+    
+    logger.info(f"✅ Created fallback response with {len(fallback)} fields")
+    return fallback
+
+
+def robust_json_parse(
+    response: Union[str, dict, BaseModel],
+    target_model: type,
+    required_fields: Dict[str, Any],
+    optional_fields: Dict[str, Any] = None
+) -> BaseModel:
+    """
+    Robust JSON parsing with intelligent fallbacks.
+    
+    Args:
+        response: LLM response (string, dict, or Pydantic model)
+        target_model: Pydantic model class to create
+        required_fields: Required fields with default values
+        optional_fields: Optional fields with default values
+        
+    Returns:
+        Instance of target_model
+        
+    Raises:
+        ValueError: If parsing fails completely
+    """
+    logger.debug(f"🔧 Parsing response of type {type(response).__name__} into {target_model.__name__}")
+    
+    # If already the target model, return as-is
+    if isinstance(response, target_model):
+        logger.debug("✅ Response is already target model")
+        return response
+    
+    # If dict, try to create model directly
+    if isinstance(response, dict):
+        try:
+            result = target_model(**response)
+            logger.debug("✅ Successfully created model from dict")
+            return result
+        except Exception as e:
+            logger.debug(f"❌ Failed to create model from dict: {e}")
+    
+    # If string, try JSON extraction
+    if isinstance(response, str):
+        extracted_json = extract_json_from_text(response)
+        
+        if extracted_json:
+            try:
+                result = target_model(**extracted_json)
+                logger.debug("✅ Successfully created model from extracted JSON")
+                return result
+            except Exception as e:
+                logger.debug(f"❌ Failed to create model from extracted JSON: {e}")
+        
+        # Create fallback response
+        logger.info("🔄 Creating fallback response for string input")
+        fallback_data = create_fallback_response(
+            response, 
+            required_fields, 
+            optional_fields
+        )
+        
+        try:
+            result = target_model(**fallback_data)
+            logger.info("✅ Successfully created model from fallback data")
+            return result
+        except Exception as e:
+            logger.error(f"❌ Failed to create fallback response: {e}")
+            raise ValueError(f"Failed to create fallback response: {e}")
+    
+    # Unexpected response type
+    error_msg = f"Unable to parse response of type {type(response)}: {response}"
+    logger.error(f"❌ {error_msg}")
+    raise ValueError(error_msg)
+
+
+def parse_with_fallback(response: Any, model_class: type, **field_defaults) -> BaseModel:
+    """
+    Convenience function for parsing with automatic field detection.
+    
+    Args:
+        response: LLM response to parse
+        model_class: Pydantic model class
+        **field_defaults: Default values for fields (field_name=default_value)
+        
+    Returns:
+        Instance of model_class
+    """
+    # Extract required fields from model
+    required_fields = {}
+    optional_fields = {}
+    
+    # Get field info from Pydantic model
+    if hasattr(model_class, 'model_fields'):
+        for field_name, field_info in model_class.model_fields.items():
+            default_value = field_defaults.get(field_name, "")
+            
+            if field_info.is_required():
+                required_fields[field_name] = default_value
+            else:
+                optional_fields[field_name] = field_info.default
+    
+    return robust_json_parse(response, model_class, required_fields, optional_fields) 

{dacp-0.3.2 → dacp-0.3.3}/dacp/orchestrator.py

@@ -120,6 +120,17 @@ class Orchestrator:
             # Call the agent's message handler
             response = agent.handle_message(message)
 
+            # Handle Pydantic models by converting to dict
+            if hasattr(response, 'model_dump'):
+                logger.debug(f"📊 Converting Pydantic model to dict: {type(response).__name__}")
+                response = response.model_dump()
+            elif not isinstance(response, dict):
+                logger.debug(f"📊 Converting response to dict: {type(response)}")
+                if hasattr(response, '__dict__'):
+                    response = response.__dict__
+                else:
+                    response = {"result": str(response)}
+
             duration = time.time() - start_time
             logger.info(f"✅ Agent '{agent_name}' responded in {duration:.3f}s")
             logger.debug(f"📤 Agent response: {response}")
@@ -229,6 +240,7 @@ class Orchestrator:
         entry = {
             "timestamp": time.time(),
             "session_id": self.session_id,
+            "agent": agent_name,
             "agent_name": agent_name,
             "message": message,
             "response": response,

dacp-0.3.3/dacp/workflow.py

@@ -0,0 +1,409 @@
+"""
+DACP Workflow Management - Agent-to-agent communication and task routing.
+
+This module provides workflow orchestration capabilities for multi-agent systems,
+including task boards, message routing, and automated agent collaboration.
+"""
+
+import logging
+import time
+import uuid
+from typing import Dict, Any, List, Optional, Callable
+from dataclasses import dataclass, field
+from enum import Enum
+
+logger = logging.getLogger("dacp.workflow")
+
+
+class TaskStatus(Enum):
+    """Task status enumeration."""
+    PENDING = "pending"
+    ASSIGNED = "assigned"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class TaskPriority(Enum):
+    """Task priority enumeration."""
+    LOW = 1
+    NORMAL = 2
+    HIGH = 3
+    URGENT = 4
+
+
+@dataclass
+class Task:
+    """Represents a task in the workflow system."""
+    id: str
+    type: str
+    data: Dict[str, Any]
+    source_agent: str
+    target_agent: Optional[str] = None
+    status: TaskStatus = TaskStatus.PENDING
+    priority: TaskPriority = TaskPriority.NORMAL
+    created_at: float = field(default_factory=time.time)
+    assigned_at: Optional[float] = None
+    completed_at: Optional[float] = None
+    result: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+    dependencies: List[str] = field(default_factory=list)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert task to dictionary representation."""
+        return {
+            "id": self.id,
+            "type": self.type,
+            "data": self.data,
+            "source_agent": self.source_agent,
+            "target_agent": self.target_agent,
+            "status": self.status.value,
+            "priority": self.priority.value,
+            "created_at": self.created_at,
+            "assigned_at": self.assigned_at,
+            "completed_at": self.completed_at,
+            "result": self.result,
+            "error": self.error,
+            "dependencies": self.dependencies,
+            "metadata": self.metadata,
+        }
+
+
+@dataclass
+class WorkflowRule:
+    """Defines routing rules for agent-to-agent communication."""
+    source_task_type: str
+    target_agent: str
+    target_task_type: str
+    condition: Optional[Callable[[Task], bool]] = None
+    transform_data: Optional[Callable[[Dict[str, Any]], Dict[str, Any]]] = None
+    priority: TaskPriority = TaskPriority.NORMAL
+
+
+class TaskBoard:
+    """Central task board for managing agent-to-agent tasks."""
+
+    def __init__(self):
+        self.tasks: Dict[str, Task] = {}
+        self.agent_queues: Dict[str, List[str]] = {}
+        self.completed_tasks: List[str] = []
+        self.workflow_rules: List[WorkflowRule] = []
+
+    def add_task(
+        self,
+        task_type: str,
+        data: Dict[str, Any],
+        source_agent: str,
+        target_agent: Optional[str] = None,
+        priority: TaskPriority = TaskPriority.NORMAL,
+        dependencies: List[str] = None,
+    ) -> str:
+        """Add a new task to the board."""
+        task_id = str(uuid.uuid4())
+        
+        task = Task(
+            id=task_id,
+            type=task_type,
+            data=data,
+            source_agent=source_agent,
+            target_agent=target_agent,
+            priority=priority,
+            dependencies=dependencies or [],
+        )
+
+        self.tasks[task_id] = task
+
+        # Add to appropriate agent queue
+        if target_agent:
+            if target_agent not in self.agent_queues:
+                self.agent_queues[target_agent] = []
+            self.agent_queues[target_agent].append(task_id)
+            task.status = TaskStatus.ASSIGNED
+            task.assigned_at = time.time()
+
+        logger.info(f"📋 Task '{task_id}' added: {task_type} from {source_agent} to {target_agent}")
+        return task_id
+
+    def get_next_task(self, agent_name: str) -> Optional[Task]:
+        """Get the next task for an agent."""
+        if agent_name not in self.agent_queues or not self.agent_queues[agent_name]:
+            return None
+
+        # Sort by priority and creation time
+        queue = self.agent_queues[agent_name]
+        available_tasks = []
+
+        for task_id in queue:
+            task = self.tasks[task_id]
+            if task.status == TaskStatus.ASSIGNED and self._dependencies_satisfied(task):
+                available_tasks.append(task)
+
+        if not available_tasks:
+            return None
+
+        # Sort by priority (higher first) then by creation time (older first)
+        available_tasks.sort(key=lambda t: (-t.priority.value, t.created_at))
+        
+        next_task = available_tasks[0]
+        next_task.status = TaskStatus.IN_PROGRESS
+
+        logger.info(f"📤 Task '{next_task.id}' assigned to agent '{agent_name}'")
+        return next_task
+
+    def complete_task(
+        self, 
+        task_id: str, 
+        result: Dict[str, Any], 
+        trigger_rules: bool = True
+    ) -> None:
+        """Mark a task as completed and trigger workflow rules."""
+        if task_id not in self.tasks:
+            logger.error(f"❌ Task '{task_id}' not found")
+            return
+
+        task = self.tasks[task_id]
+        task.status = TaskStatus.COMPLETED
+        task.completed_at = time.time()
+        task.result = result
+
+        # Remove from agent queue
+        if task.target_agent and task.target_agent in self.agent_queues:
+            if task_id in self.agent_queues[task.target_agent]:
+                self.agent_queues[task.target_agent].remove(task_id)
+
+        self.completed_tasks.append(task_id)
+
+        logger.info(f"✅ Task '{task_id}' completed by agent '{task.target_agent}'")
+
+        # Trigger workflow rules if enabled
+        if trigger_rules:
+            self._trigger_workflow_rules(task)
+
+    def fail_task(self, task_id: str, error: str) -> None:
+        """Mark a task as failed."""
+        if task_id not in self.tasks:
+            logger.error(f"❌ Task '{task_id}' not found")
+            return
+
+        task = self.tasks[task_id]
+        task.status = TaskStatus.FAILED
+        task.completed_at = time.time()
+        task.error = error
+
+        # Remove from agent queue
+        if task.target_agent and task.target_agent in self.agent_queues:
+            if task_id in self.agent_queues[task.target_agent]:
+                self.agent_queues[task.target_agent].remove(task_id)
+
+        logger.error(f"❌ Task '{task_id}' failed: {error}")
+
+    def add_workflow_rule(self, rule: WorkflowRule) -> None:
+        """Add a workflow rule for automatic task routing."""
+        self.workflow_rules.append(rule)
+        logger.info(
+            f"🔄 Workflow rule added: {rule.source_task_type} → "
+            f"{rule.target_agent} ({rule.target_task_type})"
+        )
+
+    def _dependencies_satisfied(self, task: Task) -> bool:
+        """Check if all task dependencies are satisfied."""
+        for dep_id in task.dependencies:
+            if dep_id not in self.tasks:
+                return False
+            dep_task = self.tasks[dep_id]
+            if dep_task.status != TaskStatus.COMPLETED:
+                return False
+        return True
+
+    def _trigger_workflow_rules(self, completed_task: Task) -> None:
+        """Trigger workflow rules based on completed task."""
+        for rule in self.workflow_rules:
+            if rule.source_task_type == completed_task.type:
+                # Check condition if specified
+                if rule.condition and not rule.condition(completed_task):
+                    continue
+
+                # Transform data if specified
+                if rule.transform_data and completed_task.result:
+                    new_data = rule.transform_data(completed_task.result)
+                else:
+                    new_data = completed_task.result or {}
+
+                # Create new task
+                new_task_id = self.add_task(
+                    task_type=rule.target_task_type,
+                    data=new_data,
+                    source_agent=completed_task.target_agent or completed_task.source_agent,
+                    target_agent=rule.target_agent,
+                    priority=rule.priority,
+                )
+
+                logger.info(
+                    f"🔄 Workflow rule triggered: {completed_task.id} → {new_task_id}"
+                )
+
+    def get_task_status(self, task_id: str) -> Optional[Dict[str, Any]]:
+        """Get task status and details."""
+        if task_id not in self.tasks:
+            return None
+        return self.tasks[task_id].to_dict()
+
+    def get_agent_queue_status(self, agent_name: str) -> Dict[str, Any]:
+        """Get status of an agent's task queue."""
+        if agent_name not in self.agent_queues:
+            return {"agent": agent_name, "queue_length": 0, "tasks": []}
+
+        queue = self.agent_queues[agent_name]
+        task_details = []
+
+        for task_id in queue:
+            if task_id in self.tasks:
+                task = self.tasks[task_id]
+                task_details.append({
+                    "id": task_id,
+                    "type": task.type,
+                    "status": task.status.value,
+                    "priority": task.priority.value,
+                    "created_at": task.created_at,
+                })
+
+        return {
+            "agent": agent_name,
+            "queue_length": len(queue),
+            "tasks": task_details,
+        }
+
+    def get_workflow_summary(self) -> Dict[str, Any]:
+        """Get overall workflow summary."""
+        status_counts = {}
+        for task in self.tasks.values():
+            status = task.status.value
+            status_counts[status] = status_counts.get(status, 0) + 1
+
+        return {
+            "total_tasks": len(self.tasks),
+            "status_counts": status_counts,
+            "agent_queues": {
+                agent: len(queue) for agent, queue in self.agent_queues.items()
+            },
+            "completed_tasks": len(self.completed_tasks),
+            "workflow_rules": len(self.workflow_rules),
+        }
+
+
+class WorkflowOrchestrator:
+    """Enhanced orchestrator with workflow and agent-to-agent communication."""
+
+    def __init__(self, orchestrator):
+        """Initialize with a base orchestrator."""
+        self.orchestrator = orchestrator
+        self.task_board = TaskBoard()
+        self.auto_processing = False
+        self._processing_interval = 1.0  # seconds
+
+    def enable_auto_processing(self, interval: float = 1.0) -> None:
+        """Enable automatic task processing."""
+        self.auto_processing = True
+        self._processing_interval = interval
+        logger.info(f"🤖 Auto-processing enabled (interval: {interval}s)")
+
+    def disable_auto_processing(self) -> None:
+        """Disable automatic task processing."""
+        self.auto_processing = False
+        logger.info("⏸️  Auto-processing disabled")
+
+    def submit_task_for_agent(
+        self,
+        source_agent: str,
+        target_agent: str,
+        task_type: str,
+        task_data: Dict[str, Any],
+        priority: TaskPriority = TaskPriority.NORMAL,
+    ) -> str:
+        """Submit a task from one agent to another."""
+        return self.task_board.add_task(
+            task_type=task_type,
+            data=task_data,
+            source_agent=source_agent,
+            target_agent=target_agent,
+            priority=priority,
+        )
+
+    def process_agent_tasks(self, agent_name: str, max_tasks: int = 1) -> List[Dict[str, Any]]:
+        """Process available tasks for an agent."""
+        if agent_name not in self.orchestrator.agents:
+            logger.error(f"❌ Agent '{agent_name}' not registered")
+            return []
+
+        results = []
+        tasks_processed = 0
+
+        while tasks_processed < max_tasks:
+            task = self.task_board.get_next_task(agent_name)
+            if not task:
+                break
+
+            try:
+                # Convert task to agent message format
+                # Only include the task type and the actual task data
+                message = {
+                    "task": task.type,
+                    **task.data,
+                }
+
+                # Send to agent
+                response = self.orchestrator.send_message(agent_name, message)
+
+                if "error" in response:
+                    self.task_board.fail_task(task.id, response["error"])
+                    results.append({"task_id": task.id, "status": "failed", "error": response["error"]})
+                else:
+                    self.task_board.complete_task(task.id, response)
+                    results.append({"task_id": task.id, "status": "completed", "result": response})
+
+                tasks_processed += 1
+
+            except Exception as e:
+                error_msg = f"Task processing failed: {e}"
+                self.task_board.fail_task(task.id, error_msg)
+                results.append({"task_id": task.id, "status": "failed", "error": error_msg})
+                tasks_processed += 1
+
+        return results
+
+    def add_workflow_rule(
+        self,
+        source_task_type: str,
+        target_agent: str,
+        target_task_type: str,
+        condition: Optional[Callable[[Task], bool]] = None,
+        transform_data: Optional[Callable[[Dict[str, Any]], Dict[str, Any]]] = None,
+        priority: TaskPriority = TaskPriority.NORMAL,
+    ) -> None:
+        """Add a workflow rule for automatic task chaining."""
+        rule = WorkflowRule(
+            source_task_type=source_task_type,
+            target_agent=target_agent,
+            target_task_type=target_task_type,
+            condition=condition,
+            transform_data=transform_data,
+            priority=priority,
+        )
+        self.task_board.add_workflow_rule(rule)
+
+    def get_workflow_status(self) -> Dict[str, Any]:
+        """Get comprehensive workflow status."""
+        return {
+            "orchestrator": {
+                "session_id": self.orchestrator.session_id,
+                "registered_agents": list(self.orchestrator.agents.keys()),
+                "auto_processing": self.auto_processing,
+            },
+            "task_board": self.task_board.get_workflow_summary(),
+            "agent_queues": {
+                agent: self.task_board.get_agent_queue_status(agent)
+                for agent in self.orchestrator.agents.keys()
+            },
+        } 

dacp-0.3.3/dacp/workflow_runtime.py

@@ -0,0 +1,508 @@
+"""
+DACP Workflow Runtime - Declarative workflow execution from workflow.yaml
+
+This module provides a runtime system that reads workflow.yaml files and
+orchestrates agent collaboration through agent and task registries.
+"""
+
+import logging
+import time
+import uuid
+import yaml
+import json
+from typing import Dict, Any, List, Optional, Union
+from pathlib import Path
+from dataclasses import dataclass, field
+from enum import Enum
+
+logger = logging.getLogger("dacp.workflow_runtime")
+
+
+class TaskStatus(Enum):
+    """Task execution status."""
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+@dataclass
+class TaskExecution:
+    """Represents a task execution instance."""
+    id: str
+    workflow_id: str
+    step_id: str
+    agent_id: str
+    task_name: str
+    input_data: Dict[str, Any]
+    status: TaskStatus = TaskStatus.PENDING
+    output_data: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+    created_at: float = field(default_factory=time.time)
+    started_at: Optional[float] = None
+    completed_at: Optional[float] = None
+    duration: Optional[float] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary representation."""
+        return {
+            "id": self.id,
+            "workflow_id": self.workflow_id,
+            "step_id": self.step_id,
+            "agent_id": self.agent_id,
+            "task_name": self.task_name,
+            "input_data": self.input_data,
+            "status": self.status.value,
+            "output_data": self.output_data,
+            "error": self.error,
+            "created_at": self.created_at,
+            "started_at": self.started_at,
+            "completed_at": self.completed_at,
+            "duration": self.duration,
+        }
+
+
+@dataclass
+class RegisteredAgent:
+    """Represents a registered agent in the registry."""
+    id: str
+    agent_instance: Any
+    spec_file: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    registered_at: float = field(default_factory=time.time)
+    last_activity: Optional[float] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary representation."""
+        return {
+            "id": self.id,
+            "agent_type": type(self.agent_instance).__name__,
+            "spec_file": self.spec_file,
+            "metadata": self.metadata,
+            "registered_at": self.registered_at,
+            "last_activity": self.last_activity,
+        }
+
+
+class AgentRegistry:
+    """Registry for managing agent instances."""
+
+    def __init__(self):
+        self.agents: Dict[str, RegisteredAgent] = {}
+
+    def register_agent(
+        self, 
+        agent_id: str, 
+        agent_instance: Any, 
+        spec_file: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> None:
+        """Register an agent instance."""
+        registered_agent = RegisteredAgent(
+            id=agent_id,
+            agent_instance=agent_instance,
+            spec_file=spec_file,
+            metadata=metadata or {}
+        )
+        
+        self.agents[agent_id] = registered_agent
+        logger.info(f"🤖 Agent '{agent_id}' registered in registry")
+
+    def get_agent(self, agent_id: str) -> Optional[Any]:
+        """Get an agent instance by ID."""
+        if agent_id in self.agents:
+            self.agents[agent_id].last_activity = time.time()
+            return self.agents[agent_id].agent_instance
+        return None
+
+    def list_agents(self) -> List[str]:
+        """List all registered agent IDs."""
+        return list(self.agents.keys())
+
+    def get_agent_info(self, agent_id: str) -> Optional[Dict[str, Any]]:
+        """Get agent registration information."""
+        if agent_id in self.agents:
+            return self.agents[agent_id].to_dict()
+        return None
+
+    def unregister_agent(self, agent_id: str) -> bool:
+        """Unregister an agent."""
+        if agent_id in self.agents:
+            del self.agents[agent_id]
+            logger.info(f"🗑️ Agent '{agent_id}' unregistered from registry")
+            return True
+        return False
+
+
+class TaskRegistry:
+    """Registry for managing task executions."""
+
+    def __init__(self):
+        self.tasks: Dict[str, TaskExecution] = {}
+        self.workflow_tasks: Dict[str, List[str]] = {}  # workflow_id -> task_ids
+
+    def create_task(
+        self,
+        workflow_id: str,
+        step_id: str,
+        agent_id: str,
+        task_name: str,
+        input_data: Dict[str, Any]
+    ) -> str:
+        """Create a new task execution."""
+        task_id = str(uuid.uuid4())
+        
+        task = TaskExecution(
+            id=task_id,
+            workflow_id=workflow_id,
+            step_id=step_id,
+            agent_id=agent_id,
+            task_name=task_name,
+            input_data=input_data
+        )
+        
+        self.tasks[task_id] = task
+        
+        # Add to workflow tasks
+        if workflow_id not in self.workflow_tasks:
+            self.workflow_tasks[workflow_id] = []
+        self.workflow_tasks[workflow_id].append(task_id)
+        
+        logger.info(f"📋 Task '{task_id}' created for agent '{agent_id}' in workflow '{workflow_id}'")
+        return task_id
+
+    def get_task(self, task_id: str) -> Optional[TaskExecution]:
+        """Get a task by ID."""
+        return self.tasks.get(task_id)
+
+    def update_task_status(self, task_id: str, status: TaskStatus, **kwargs) -> bool:
+        """Update task status and optional fields."""
+        if task_id not in self.tasks:
+            return False
+        
+        task = self.tasks[task_id]
+        task.status = status
+        
+        # Update optional fields
+        for key, value in kwargs.items():
+            if hasattr(task, key):
+                setattr(task, key, value)
+        
+        # Calculate duration if completed
+        if status in [TaskStatus.COMPLETED, TaskStatus.FAILED] and task.started_at:
+            task.completed_at = time.time()
+            task.duration = task.completed_at - task.started_at
+        
+        logger.info(f"📊 Task '{task_id}' status updated to {status.value}")
+        return True
+
+    def get_workflow_tasks(self, workflow_id: str) -> List[TaskExecution]:
+        """Get all tasks for a workflow."""
+        task_ids = self.workflow_tasks.get(workflow_id, [])
+        return [self.tasks[tid] for tid in task_ids if tid in self.tasks]
+
+    def get_task_summary(self) -> Dict[str, Any]:
+        """Get summary of all tasks."""
+        status_counts = {}
+        for task in self.tasks.values():
+            status = task.status.value
+            status_counts[status] = status_counts.get(status, 0) + 1
+        
+        return {
+            "total_tasks": len(self.tasks),
+            "status_counts": status_counts,
+            "workflows": len(self.workflow_tasks)
+        }
+
+
+class WorkflowRuntime:
+    """DACP Workflow Runtime - Executes workflows from workflow.yaml"""
+
+    def __init__(self, orchestrator=None):
+        self.orchestrator = orchestrator
+        self.agent_registry = AgentRegistry()
+        self.task_registry = TaskRegistry()
+        self.workflow_config = {}
+        self.active_workflows: Dict[str, Dict[str, Any]] = {}
+
+    def load_workflow_config(self, config_path: str) -> None:
+        """Load workflow configuration from YAML file."""
+        config_file = Path(config_path)
+        if not config_file.exists():
+            raise FileNotFoundError(f"Workflow config file not found: {config_path}")
+        
+        with open(config_file, 'r') as f:
+            self.workflow_config = yaml.safe_load(f)
+        
+        logger.info(f"📁 Loaded workflow config from {config_path}")
+        logger.info(f"📋 Found {len(self.workflow_config.get('workflows', {}))} workflows")
+
+    def register_agent_from_config(self, agent_id: str, agent_instance: Any) -> None:
+        """Register an agent instance based on workflow config."""
+        # Find agent spec in config
+        agent_spec = None
+        for agent_config in self.workflow_config.get('agents', []):
+            if agent_config['id'] == agent_id:
+                agent_spec = agent_config.get('spec')
+                break
+        
+        self.agent_registry.register_agent(
+            agent_id=agent_id,
+            agent_instance=agent_instance,
+            spec_file=agent_spec,
+            metadata={"config_based": True}
+        )
+
+    def execute_workflow(self, workflow_name: str, initial_input: Dict[str, Any] = None) -> str:
+        """Execute a workflow by name."""
+        if workflow_name not in self.workflow_config.get('workflows', {}):
+            raise ValueError(f"Workflow '{workflow_name}' not found in config")
+        
+        workflow_def = self.workflow_config['workflows'][workflow_name]
+        workflow_id = str(uuid.uuid4())
+        
+        logger.info(f"🚀 Starting workflow '{workflow_name}' with ID '{workflow_id}'")
+        
+        # Initialize workflow state
+        self.active_workflows[workflow_id] = {
+            "name": workflow_name,
+            "definition": workflow_def,
+            "current_step": 0,
+            "context": initial_input or {},
+            "started_at": time.time()
+        }
+        
+        # Execute first step
+        self._execute_workflow_step(workflow_id, 0)
+        
+        return workflow_id
+
+    def _execute_workflow_step(self, workflow_id: str, step_index: int) -> None:
+        """Execute a specific workflow step."""
+        if workflow_id not in self.active_workflows:
+            logger.error(f"❌ Workflow '{workflow_id}' not found")
+            return
+        
+        workflow_state = self.active_workflows[workflow_id]
+        workflow_def = workflow_state["definition"]
+        steps = workflow_def.get("steps", [])
+        
+        if step_index >= len(steps):
+            logger.info(f"🏁 Workflow '{workflow_id}' completed")
+            return
+        
+        step = steps[step_index]
+        step_id = f"step_{step_index}"
+        
+        # Extract step configuration
+        agent_id = step.get("agent")
+        task_name = step.get("task")
+        step_input = step.get("input", {})
+        
+        # Resolve input data with context
+        resolved_input = self._resolve_input_data(step_input, workflow_state["context"])
+        
+        logger.info(f"📋 Executing step {step_index}: {agent_id}.{task_name}")
+        
+        # Create task
+        task_id = self.task_registry.create_task(
+            workflow_id=workflow_id,
+            step_id=step_id,
+            agent_id=agent_id,
+            task_name=task_name,
+            input_data=resolved_input
+        )
+        
+        # Execute task
+        self._execute_task(task_id, workflow_id, step_index)
+
+    def _execute_task(self, task_id: str, workflow_id: str, step_index: int) -> None:
+        """Execute a single task."""
+        task = self.task_registry.get_task(task_id)
+        if not task:
+            logger.error(f"❌ Task '{task_id}' not found")
+            return
+        
+        # Get agent instance
+        agent = self.agent_registry.get_agent(task.agent_id)
+        if not agent:
+            self.task_registry.update_task_status(
+                task_id, TaskStatus.FAILED, 
+                error=f"Agent '{task.agent_id}' not found"
+            )
+            return
+        
+        # Update task status
+        self.task_registry.update_task_status(
+            task_id, TaskStatus.RUNNING, 
+            started_at=time.time()
+        )
+        
+        try:
+            # Prepare message for agent
+            message = {
+                "task": task.task_name,
+                **task.input_data
+            }
+            
+            logger.info(f"📨 Sending task '{task.task_name}' to agent '{task.agent_id}'")
+            
+            # Execute via orchestrator or direct call
+            if self.orchestrator:
+                result = self.orchestrator.send_message(task.agent_id, message)
+            else:
+                result = agent.handle_message(message)
+            
+            # Check for errors
+            if isinstance(result, dict) and "error" in result:
+                self.task_registry.update_task_status(
+                    task_id, TaskStatus.FAILED,
+                    error=result["error"]
+                )
+                logger.error(f"❌ Task '{task_id}' failed: {result['error']}")
+                return
+            
+            # Task completed successfully
+            self.task_registry.update_task_status(
+                task_id, TaskStatus.COMPLETED,
+                output_data=result
+            )
+            
+            logger.info(f"✅ Task '{task_id}' completed successfully")
+            
+            # Continue workflow
+            self._handle_task_completion(task_id, workflow_id, step_index, result)
+            
+        except Exception as e:
+            self.task_registry.update_task_status(
+                task_id, TaskStatus.FAILED,
+                error=str(e)
+            )
+            logger.error(f"❌ Task '{task_id}' failed with exception: {e}")
+
+    def _handle_task_completion(self, task_id: str, workflow_id: str, step_index: int, result: Dict[str, Any]) -> None:
+        """Handle task completion and route to next step."""
+        workflow_state = self.active_workflows[workflow_id]
+        workflow_def = workflow_state["definition"]
+        steps = workflow_def.get("steps", [])
+        
+        if step_index >= len(steps):
+            return
+        
+        current_step = steps[step_index]
+        
+        # Convert result to dictionary if it's a Pydantic model
+        if hasattr(result, 'model_dump'):
+            result_dict = result.model_dump()
+            logger.debug(f"🔧 Converted Pydantic model to dict: {result_dict}")
+        elif hasattr(result, 'dict'):
+            result_dict = result.dict()
+            logger.debug(f"🔧 Converted Pydantic model to dict (legacy): {result_dict}")
+        else:
+            result_dict = result
+        
+        # Update workflow context with result
+        workflow_state["context"].update({"output": result_dict})
+        
+        # Check for routing
+        route_config = current_step.get("route_output_to")
+        if route_config:
+            # Route to next agent
+            next_agent_id = route_config.get("agent")
+            next_task_name = route_config.get("task")
+            input_mapping = route_config.get("input_mapping", {})
+            
+            logger.debug(f"🔍 Input mapping: {input_mapping}")
+            logger.debug(f"🔍 Available output data: {result_dict}")
+            
+            # Resolve input mapping
+            next_input = self._resolve_input_mapping(input_mapping, result_dict, workflow_state["context"])
+            
+            logger.info(f"🔄 Routing output to {next_agent_id}.{next_task_name}")
+            logger.debug(f"🔍 Resolved input for next task: {next_input}")
+            
+            # Create and execute next task
+            next_task_id = self.task_registry.create_task(
+                workflow_id=workflow_id,
+                step_id=f"routed_step_{step_index}",
+                agent_id=next_agent_id,
+                task_name=next_task_name,
+                input_data=next_input
+            )
+            
+            self._execute_task(next_task_id, workflow_id, step_index + 1)
+        else:
+            # Continue to next step
+            self._execute_workflow_step(workflow_id, step_index + 1)
+
+    def _resolve_input_data(self, input_config: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]:
+        """Resolve input data with context variables."""
+        resolved = {}
+        for key, value in input_config.items():
+            if isinstance(value, str) and value.startswith("{{") and value.endswith("}}"):
+                # Template variable
+                var_path = value[2:-2].strip()
+                resolved[key] = self._get_nested_value(context, var_path)
+            else:
+                resolved[key] = value
+        return resolved
+
+    def _resolve_input_mapping(self, mapping: Dict[str, str], output: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]:
+        """Resolve input mapping with output and context."""
+        resolved = {}
+        for target_key, source_template in mapping.items():
+            if isinstance(source_template, str) and source_template.startswith("{{") and source_template.endswith("}}"):
+                var_path = source_template[2:-2].strip()
+                if var_path.startswith("output."):
+                    # From current output
+                    field_name = var_path[7:]  # Remove "output."
+                    resolved[target_key] = output.get(field_name, "")
+                else:
+                    # From context
+                    resolved[target_key] = self._get_nested_value(context, var_path)
+            else:
+                resolved[target_key] = source_template
+        return resolved
+
+    def _get_nested_value(self, data: Dict[str, Any], path: str) -> Any:
+        """Get nested value from dictionary using dot notation."""
+        keys = path.split('.')
+        current = data
+        for key in keys:
+            if isinstance(current, dict) and key in current:
+                current = current[key]
+            else:
+                return None
+        return current
+
+    def get_workflow_status(self, workflow_id: str) -> Optional[Dict[str, Any]]:
+        """Get workflow execution status."""
+        if workflow_id not in self.active_workflows:
+            return None
+        
+        workflow_state = self.active_workflows[workflow_id]
+        tasks = self.task_registry.get_workflow_tasks(workflow_id)
+        
+        return {
+            "workflow_id": workflow_id,
+            "name": workflow_state["name"],
+            "current_step": workflow_state["current_step"],
+            "started_at": workflow_state["started_at"],
+            "context": workflow_state["context"],
+            "tasks": [task.to_dict() for task in tasks]
+        }
+
+    def get_runtime_status(self) -> Dict[str, Any]:
+        """Get overall runtime status."""
+        return {
+            "agents": {
+                "registered": len(self.agent_registry.agents),
+                "agents": [agent.to_dict() for agent in self.agent_registry.agents.values()]
+            },
+            "tasks": self.task_registry.get_task_summary(),
+            "workflows": {
+                "active": len(self.active_workflows),
+                "configured": len(self.workflow_config.get('workflows', {}))
+            }
+        } 

{dacp-0.3.2 → dacp-0.3.3}/dacp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dacp
-Version: 0.3.2
+Version: 0.3.3
 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

{dacp-0.3.2 → dacp-0.3.3}/dacp.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 dacp/__init__.py
 dacp/exceptions.py
 dacp/intelligence.py
+dacp/json_parser.py
 dacp/llm.py
 dacp/logging_config.py
 dacp/main.py
@@ -11,6 +12,8 @@ dacp/orchestrator.py
 dacp/protocol.py
 dacp/tools.py
 dacp/types.py
+dacp/workflow.py
+dacp/workflow_runtime.py
 dacp.egg-info/PKG-INFO
 dacp.egg-info/SOURCES.txt
 dacp.egg-info/dependency_links.txt

{dacp-0.3.2 → dacp-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dacp"
-version = "0.3.2"
+version = "0.3.3"
 description = "Declarative Agent Communication Protocol - A protocol for managing LLM/agent communications and tool function calls"
 readme = "README.md"
 license = {text = "MIT"}