dacp 0.3.2__tar.gz → 0.3.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dacp
-Version: 0.3.2
+Version: 0.3.4
 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
@@ -26,20 +26,25 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.25.0
 Requires-Dist: pyyaml>=5.4.0
+Requires-Dist: pydantic>=2.0.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: api
+Requires-Dist: fastapi>=0.104.0; extra == "api"
+Requires-Dist: uvicorn[standard]>=0.24.0; extra == "api"
 Provides-Extra: all
 Requires-Dist: openai>=1.0.0; extra == "all"
 Requires-Dist: anthropic>=0.18.0; extra == "all"
+Requires-Dist: fastapi>=0.104.0; extra == "all"
+Requires-Dist: uvicorn[standard]>=0.24.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: ruff>=0.1.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"

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

@@ -24,8 +24,30 @@ 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"
+__version__ = "0.3.3"
 
 __all__ = [
     # Protocol functions
@@ -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.4/dacp/api.py

@@ -0,0 +1,365 @@
+#!/usr/bin/env python3
+"""
+DACP REST API Server
+
+Provides HTTP endpoints for running workflows and managing agents.
+"""
+
+import json
+import logging
+import time
+import uuid
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+import uvicorn
+
+import dacp
+from dacp.workflow_runtime import WorkflowRuntime
+
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("dacp.api")
+
+
+# Pydantic models for API requests/responses
+class WorkflowExecuteRequest(BaseModel):
+    workflow_file: str = Field(..., description="Path to workflow YAML file")
+    workflow_name: str = Field(..., description="Name of workflow to execute")
+    input_data: Dict[str, Any] = Field(default_factory=dict, description="Input data for workflow")
+    session_id: Optional[str] = Field(None, description="Custom session ID")
+    wait_for_completion: bool = Field(True, description="Wait for workflow completion or return immediately")
+
+
+class WorkflowStatusResponse(BaseModel):
+    workflow_id: str
+    status: str
+    created_at: float
+    started_at: Optional[float]
+    completed_at: Optional[float]
+    duration: Optional[float]
+    result: Optional[Dict[str, Any]]
+    error: Optional[str]
+    steps: Optional[Dict[str, Any]]
+
+
+class WorkflowListResponse(BaseModel):
+    workflows: Dict[str, Dict[str, Any]]
+    agents: list
+
+
+class HealthResponse(BaseModel):
+    status: str
+    version: str
+    uptime: float
+    active_workflows: int
+
+
+# Global state
+app = FastAPI(
+    title="DACP REST API",
+    description="REST API for Declarative Agent Communication Protocol",
+    version="0.3.3"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure appropriately for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global runtime and session tracking
+runtime: Optional[WorkflowRuntime] = None
+orchestrator: Optional[dacp.Orchestrator] = None
+start_time = time.time()
+active_workflows: Dict[str, Dict[str, Any]] = {}
+
+
+def get_runtime() -> WorkflowRuntime:
+    """Get or create the global workflow runtime."""
+    global runtime, orchestrator
+    
+    if runtime is None:
+        orchestrator = dacp.Orchestrator(session_id=f"api-{int(time.time())}")
+        runtime = dacp.WorkflowRuntime(orchestrator=orchestrator)
+        logger.info("🚀 DACP API runtime initialized")
+    
+    return runtime
+
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize the API on startup."""
+    get_runtime()
+    logger.info("🎭 DACP REST API server started")
+
+
+@app.get("/", response_model=Dict[str, str])
+async def root():
+    """Root endpoint with API information."""
+    return {
+        "message": "DACP REST API",
+        "version": "0.3.2",
+        "docs": "/docs",
+        "health": "/health"
+    }
+
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Health check endpoint."""
+    global active_workflows
+    
+    return HealthResponse(
+        status="healthy",
+        version="0.3.3",
+        uptime=time.time() - start_time,
+        active_workflows=len(active_workflows)
+    )
+
+
+@app.post("/workflows/execute", response_model=WorkflowStatusResponse)
+async def execute_workflow(request: WorkflowExecuteRequest, background_tasks: BackgroundTasks):
+    """Execute a workflow."""
+    try:
+        runtime = get_runtime()
+        
+        # Validate workflow file exists
+        workflow_path = Path(request.workflow_file)
+        if not workflow_path.exists():
+            raise HTTPException(status_code=404, detail=f"Workflow file not found: {request.workflow_file}")
+        
+        # Load workflow configuration
+        runtime.load_workflow_config(str(workflow_path))
+        
+        # Generate workflow ID
+        workflow_id = str(uuid.uuid4())
+        
+        # Create initial status
+        status = WorkflowStatusResponse(
+            workflow_id=workflow_id,
+            status="pending",
+            created_at=time.time(),
+            started_at=None,
+            completed_at=None,
+            duration=None,
+            result=None,
+            error=None,
+            steps=None
+        )
+        
+        # Track active workflow
+        active_workflows[workflow_id] = {
+            "status": status,
+            "request": request,
+            "created_at": time.time()
+        }
+        
+        if request.wait_for_completion:
+            # Execute synchronously
+            try:
+                status.started_at = time.time()
+                status.status = "running"
+                
+                # Execute workflow
+                actual_workflow_id = runtime.execute_workflow(request.workflow_name, request.input_data)
+                
+                # Get results
+                workflow_status = runtime.get_workflow_status(actual_workflow_id)
+                
+                status.completed_at = time.time()
+                status.duration = status.completed_at - status.started_at
+                status.status = "completed"
+                status.result = workflow_status
+                
+                # Clean up
+                if workflow_id in active_workflows:
+                    del active_workflows[workflow_id]
+                
+                logger.info(f"✅ Workflow {workflow_id} completed in {status.duration:.2f}s")
+                
+            except Exception as e:
+                status.completed_at = time.time()
+                status.duration = status.completed_at - status.started_at
+                status.status = "failed"
+                status.error = str(e)
+                
+                # Clean up
+                if workflow_id in active_workflows:
+                    del active_workflows[workflow_id]
+                
+                logger.error(f"❌ Workflow {workflow_id} failed: {e}")
+                
+        else:
+            # Execute asynchronously
+            background_tasks.add_task(
+                execute_workflow_async,
+                workflow_id,
+                request,
+                runtime
+            )
+            logger.info(f"🚀 Workflow {workflow_id} queued for async execution")
+        
+        return status
+        
+    except Exception as e:
+        logger.error(f"❌ Workflow execution failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def execute_workflow_async(workflow_id: str, request: WorkflowExecuteRequest, runtime: WorkflowRuntime):
+    """Execute a workflow asynchronously."""
+    try:
+        # Update status to running
+        if workflow_id in active_workflows:
+            active_workflows[workflow_id]["status"].started_at = time.time()
+            active_workflows[workflow_id]["status"].status = "running"
+        
+        # Execute workflow
+        actual_workflow_id = runtime.execute_workflow(request.workflow_name, request.input_data)
+        
+        # Get results
+        workflow_status = runtime.get_workflow_status(actual_workflow_id)
+        
+        # Update status
+        if workflow_id in active_workflows:
+            status = active_workflows[workflow_id]["status"]
+            status.completed_at = time.time()
+            status.duration = status.completed_at - status.started_at
+            status.status = "completed"
+            status.result = workflow_status
+            
+            # Clean up
+            del active_workflows[workflow_id]
+        
+        logger.info(f"✅ Async workflow {workflow_id} completed")
+        
+    except Exception as e:
+        # Update status with error
+        if workflow_id in active_workflows:
+            status = active_workflows[workflow_id]["status"]
+            status.completed_at = time.time()
+            status.duration = status.completed_at - status.started_at
+            status.status = "failed"
+            status.error = str(e)
+            
+            # Clean up
+            del active_workflows[workflow_id]
+        
+        logger.error(f"❌ Async workflow {workflow_id} failed: {e}")
+
+
+@app.get("/workflows/{workflow_id}/status", response_model=WorkflowStatusResponse)
+async def get_workflow_status(workflow_id: str):
+    """Get the status of a workflow execution."""
+    if workflow_id in active_workflows:
+        return active_workflows[workflow_id]["status"]
+    else:
+        raise HTTPException(status_code=404, detail=f"Workflow {workflow_id} not found")
+
+
+@app.get("/workflows", response_model=Dict[str, Any])
+async def list_active_workflows():
+    """List all active workflows."""
+    return {
+        "active_workflows": len(active_workflows),
+        "workflows": [
+            {
+                "workflow_id": wf_id,
+                "status": wf_data["status"].status,
+                "created_at": wf_data["created_at"],
+                "workflow_name": wf_data["request"].workflow_name
+            }
+            for wf_id, wf_data in active_workflows.items()
+        ]
+    }
+
+
+@app.get("/workflows/config/{workflow_file}", response_model=WorkflowListResponse)
+async def get_workflow_config(workflow_file: str):
+    """Get workflow configuration and list available workflows."""
+    try:
+        workflow_path = Path(workflow_file)
+        if not workflow_path.exists():
+            raise HTTPException(status_code=404, detail=f"Workflow file not found: {workflow_file}")
+        
+        # Load workflow configuration
+        import yaml
+        with open(workflow_path, 'r') as f:
+            config = yaml.safe_load(f)
+        
+        return WorkflowListResponse(
+            workflows=config.get('workflows', {}),
+            agents=config.get('agents', [])
+        )
+        
+    except Exception as e:
+        logger.error(f"❌ Failed to load workflow config: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete("/workflows/{workflow_id}")
+async def cancel_workflow(workflow_id: str):
+    """Cancel a running workflow."""
+    if workflow_id not in active_workflows:
+        raise HTTPException(status_code=404, detail=f"Workflow {workflow_id} not found")
+    
+    # Update status to cancelled
+    active_workflows[workflow_id]["status"].status = "cancelled"
+    active_workflows[workflow_id]["status"].completed_at = time.time()
+    
+    # Clean up
+    del active_workflows[workflow_id]
+    
+    logger.info(f"🚫 Workflow {workflow_id} cancelled")
+    return {"message": f"Workflow {workflow_id} cancelled"}
+
+
+@app.get("/agents", response_model=Dict[str, Any])
+async def list_agents():
+    """List registered agents."""
+    runtime = get_runtime()
+    agents = runtime.agent_registry.list_agents()
+    
+    agent_info = []
+    for agent_id in agents:
+        info = runtime.agent_registry.get_agent_info(agent_id)
+        if info:
+            agent_info.append(info)
+    
+    return {
+        "agents": agent_info,
+        "total": len(agents)
+    }
+
+
+def start_server(host: str = "0.0.0.0", port: int = 8000, reload: bool = False):
+    """Start the DACP API server."""
+    logger.info(f"🚀 Starting DACP REST API server on {host}:{port}")
+    
+    uvicorn.run(
+        "dacp.api:app",
+        host=host,
+        port=port,
+        reload=reload,
+        log_level="info"
+    )
+
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="DACP REST API Server")
+    parser.add_argument("--host", default="0.0.0.0", help="Host to bind to")
+    parser.add_argument("--port", type=int, default=8000, help="Port to bind to")
+    parser.add_argument("--reload", action="store_true", help="Enable auto-reload")
+    
+    args = parser.parse_args()
+    start_server(args.host, args.port, args.reload) 

dacp-0.3.4/dacp/cli.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+"""
+DACP Command Line Interface
+
+Provides a simple CLI for running workflows and managing agents.
+"""
+
+import argparse
+import json
+import sys
+import yaml
+from pathlib import Path
+from typing import Dict, Any
+
+import dacp
+from dacp.workflow_runtime import WorkflowRuntime
+
+
+def setup_logging(args):
+    """Setup DACP logging based on CLI arguments."""
+    log_config = {
+        "level": args.log_level or "INFO",
+        "format_style": args.log_style or "emoji",
+        "include_timestamp": args.timestamp,
+    }
+    
+    if args.log_file:
+        log_config["log_file"] = args.log_file
+    
+    dacp.setup_dacp_logging(**log_config)
+
+
+def load_workflow_config(workflow_path: str) -> Dict[str, Any]:
+    """Load workflow configuration from YAML file."""
+    workflow_file = Path(workflow_path)
+    if not workflow_file.exists():
+        raise FileNotFoundError(f"Workflow file not found: {workflow_path}")
+    
+    with open(workflow_file, 'r') as f:
+        return yaml.safe_load(f)
+
+
+def parse_input_data(input_args: list) -> Dict[str, Any]:
+    """Parse input data from CLI arguments."""
+    input_data = {}
+    
+    for arg in input_args:
+        if '=' in arg:
+            key, value = arg.split('=', 1)
+            # Try to parse as JSON, fallback to string
+            try:
+                input_data[key] = json.loads(value)
+            except json.JSONDecodeError:
+                input_data[key] = value
+        else:
+            # Single value, treat as string
+            input_data[arg] = ""
+    
+    return input_data
+
+
+def run_workflow(args):
+    """Run a workflow with the given configuration."""
+    try:
+        # Setup logging
+        setup_logging(args)
+        
+        # Load workflow configuration
+        workflow_config = load_workflow_config(args.workflow)
+        
+        # Create orchestrator and runtime
+        orchestrator = dacp.Orchestrator(session_id=args.session_id)
+        runtime = dacp.WorkflowRuntime(orchestrator=orchestrator)
+        
+        # Load workflow
+        runtime.load_workflow_config(args.workflow)
+        
+        # Parse input data
+        input_data = parse_input_data(args.input or [])
+        
+        # Load and register agents
+        agents_config = workflow_config.get('agents', [])
+        for agent_config in agents_config:
+            agent_id = agent_config.get('id') or agent_config.get('name')  # Support both 'id' and 'name'
+            agent_spec = agent_config.get('spec')
+            
+            if agent_id and agent_spec:
+                print(f"📋 Loading agent: {agent_id} from {agent_spec}")
+                
+                # Check if spec is a Python module path (contains :)
+                if ':' in agent_spec:
+                    # Format: module.path:ClassName
+                    try:
+                        module_path, class_name = agent_spec.split(':')
+                        
+                        # Convert module path to file path
+                        file_path = module_path.replace('.', '/') + '.py'
+                        
+                        # Load the agent using importlib
+                        import importlib.util
+                        spec = importlib.util.spec_from_file_location(f"{agent_id}_module", file_path)
+                        agent_module = importlib.util.module_from_spec(spec)
+                        spec.loader.exec_module(agent_module)
+                        
+                        # Get the agent class and instantiate it
+                        agent_class = getattr(agent_module, class_name)
+                        agent_instance = agent_class(agent_id=agent_id, orchestrator=orchestrator)
+                        
+                        # Register with runtime
+                        runtime.register_agent_from_config(agent_id, agent_instance)
+                        print(f"✅ Agent {agent_id} loaded and registered")
+                        
+                    except Exception as e:
+                        print(f"❌ Failed to load agent {agent_id}: {e}")
+                        continue
+                        
+                else:
+                    # Legacy YAML file approach
+                    agent_path = Path(args.workflow).parent / agent_spec
+                    if agent_path.exists():
+                        print(f"⚠️  YAML agent specs not yet supported: {agent_spec}")
+                    else:
+                        print(f"❌ Agent spec file not found: {agent_spec}")
+        
+        # Execute workflow
+        print(f"🚀 Executing workflow: {args.workflow_name}")
+        workflow_id = runtime.execute_workflow(args.workflow_name, input_data)
+        
+        # Get results
+        status = runtime.get_workflow_status(workflow_id)
+        
+        if args.output:
+            with open(args.output, 'w') as f:
+                json.dump(status, f, indent=2)
+            print(f"📄 Results saved to: {args.output}")
+        else:
+            print("📊 Workflow Results:")
+            print(json.dumps(status, indent=2))
+        
+        return 0
+        
+    except Exception as e:
+        print(f"❌ Workflow execution failed: {e}")
+        return 1
+
+
+def list_workflows(args):
+    """List available workflows in a configuration file."""
+    try:
+        workflow_config = load_workflow_config(args.workflow)
+        workflows = workflow_config.get('workflows', {})
+        
+        print(f"📋 Available workflows in {args.workflow}:")
+        for name, config in workflows.items():
+            description = config.get('description', 'No description')
+            steps = len(config.get('steps', []))
+            print(f"  • {name}: {description} ({steps} steps)")
+        
+        return 0
+        
+    except Exception as e:
+        print(f"❌ Failed to list workflows: {e}")
+        return 1
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="DACP - Declarative Agent Communication Protocol CLI",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Run a workflow
+  dacp run workflow examples/github-actions-error-workflow.yaml \\
+    --workflow-name quick_error_analysis \\
+    --input job_name="build-and-test" \\
+    --input raw_logs="npm ERR! code ENOENT..." \\
+    --input repository="myorg/myproject"
+
+  # List available workflows
+  dacp list workflows examples/github-actions-error-workflow.yaml
+
+  # Run with custom logging
+  dacp run workflow workflow.yaml \\
+    --log-level DEBUG \\
+    --log-style detailed \\
+    --output results.json
+        """
+    )
+    
+    subparsers = parser.add_subparsers(dest='command', help='Available commands')
+    
+    # Run workflow command
+    run_parser = subparsers.add_parser('run', help='Run workflows and agents')
+    run_subparsers = run_parser.add_subparsers(dest='run_command', help='Run commands')
+    
+    workflow_parser = run_subparsers.add_parser('workflow', help='Run a workflow')
+    workflow_parser.add_argument('workflow', help='Path to workflow YAML file')
+    workflow_parser.add_argument('--workflow-name', required=True, help='Name of workflow to execute')
+    workflow_parser.add_argument('--input', action='append', help='Input data (key=value or just value)')
+    workflow_parser.add_argument('--output', help='Output file for results (JSON)')
+    workflow_parser.add_argument('--session-id', help='Custom session ID')
+    
+    # Logging options
+    workflow_parser.add_argument('--log-level', choices=['DEBUG', 'INFO', 'WARNING', 'ERROR'], help='Log level')
+    workflow_parser.add_argument('--log-style', choices=['emoji', 'detailed', 'simple'], help='Log style')
+    workflow_parser.add_argument('--log-file', help='Log file path')
+    workflow_parser.add_argument('--timestamp', action='store_true', help='Include timestamps in logs')
+    
+    # List command
+    list_parser = subparsers.add_parser('list', help='List available resources')
+    list_subparsers = list_parser.add_subparsers(dest='list_command', help='List commands')
+    
+    workflows_parser = list_subparsers.add_parser('workflows', help='List workflows in a file')
+    workflows_parser.add_argument('workflow', help='Path to workflow YAML file')
+    
+    # Version command
+    subparsers.add_parser('version', help='Show DACP version')
+    
+    # Serve command for REST API
+    serve_parser = subparsers.add_parser('serve', help='Start REST API server')
+    serve_parser.add_argument('--host', default='0.0.0.0', help='Host to bind to')
+    serve_parser.add_argument('--port', type=int, default=8000, help='Port to bind to')
+    serve_parser.add_argument('--reload', action='store_true', help='Enable auto-reload')
+    
+    args = parser.parse_args()
+    
+    if args.command == 'run' and args.run_command == 'workflow':
+        return run_workflow(args)
+    elif args.command == 'list' and args.list_command == 'workflows':
+        return list_workflows(args)
+    elif args.command == 'version':
+        print(f"DACP version {dacp.__version__}")
+        return 0
+    elif args.command == 'serve':
+        try:
+            from dacp.api import start_server
+            start_server(args.host, args.port, args.reload)
+            return 0
+        except ImportError:
+            print("❌ REST API dependencies not installed. Run: pip install dacp[api]")
+            return 1
+    else:
+        parser.print_help()
+        return 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())