dacp 0.3.3__py3-none-any.whl → 0.3.4__py3-none-any.whl

dacp/intelligence.py

@@ -13,9 +13,7 @@ from typing import Dict, Any, Union
 logger = logging.getLogger("dacp.intelligence")
 
 
-def invoke_intelligence(
-    prompt: str, config: Dict[str, Any]
-) -> Union[str, Dict[str, Any]]:
+def invoke_intelligence(prompt: str, config: Dict[str, Any]) -> Union[str, Dict[str, Any]]:
     """
     Invoke an intelligence provider with the given prompt and configuration.
 
@@ -54,8 +52,7 @@ def invoke_intelligence(
         else:
             available_engines = ["openai", "anthropic", "azure", "local"]
             raise ValueError(
-                f"Unsupported engine: {engine}. "
-                f"Available engines: {available_engines}"
+                f"Unsupported engine: {engine}. Available engines: {available_engines}"
             )
 
         duration = time.time() - start_time
@@ -66,10 +63,7 @@ def invoke_intelligence(
 
     except Exception as e:
         duration = time.time() - start_time
-        logger.error(
-            f"❌ Intelligence call failed after {duration:.3f}s: "
-            f"{type(e).__name__}: {e}"
-        )
+        logger.error(f"❌ Intelligence call failed after {duration:.3f}s: {type(e).__name__}: {e}")
         raise
 
 
@@ -95,8 +89,7 @@ def _invoke_openai(prompt: str, config: Dict[str, Any]) -> str:
     if not api_key:
         logger.error("❌ OpenAI API key not found")
         raise ValueError(
-            "OpenAI API key not found in config or OPENAI_API_KEY "
-            "environment variable"
+            "OpenAI API key not found in config or OPENAI_API_KEY environment variable"
         )
 
     # Configure client
@@ -111,10 +104,7 @@ def _invoke_openai(prompt: str, config: Dict[str, Any]) -> str:
     temperature = config.get("temperature", 0.7)
     max_tokens = config.get("max_tokens", 1000)
 
-    logger.debug(
-        f"🔧 OpenAI config: model={model}, temp={temperature}, "
-        f"max_tokens={max_tokens}"
-    )
+    logger.debug(f"🔧 OpenAI config: model={model}, temp={temperature}, max_tokens={max_tokens}")
 
     # Make API call
     response = client.chat.completions.create(
@@ -143,8 +133,7 @@ def _invoke_anthropic(prompt: str, config: Dict[str, Any]) -> str:
     if not api_key:
         logger.error("❌ Anthropic API key not found")
         raise ValueError(
-            "Anthropic API key not found in config or ANTHROPIC_API_KEY "
-            "environment variable"
+            "Anthropic API key not found in config or ANTHROPIC_API_KEY environment variable"
         )
 
     # Configure client
@@ -159,10 +148,7 @@ def _invoke_anthropic(prompt: str, config: Dict[str, Any]) -> str:
     temperature = config.get("temperature", 0.7)
     max_tokens = config.get("max_tokens", 1000)
 
-    logger.debug(
-        f"🔧 Anthropic config: model={model}, temp={temperature}, "
-        f"max_tokens={max_tokens}"
-    )
+    logger.debug(f"🔧 Anthropic config: model={model}, temp={temperature}, max_tokens={max_tokens}")
 
     # Make API call
     response = client.messages.create(
@@ -195,8 +181,7 @@ def _invoke_azure_openai(prompt: str, config: Dict[str, Any]) -> str:
     if not api_key:
         logger.error("❌ Azure OpenAI API key not found")
         raise ValueError(
-            "Azure OpenAI API key not found in config or "
-            "AZURE_OPENAI_API_KEY environment variable"
+            "Azure OpenAI API key not found in config or AZURE_OPENAI_API_KEY environment variable"
         )
 
     if not endpoint:
@@ -207,9 +192,7 @@ def _invoke_azure_openai(prompt: str, config: Dict[str, Any]) -> str:
         )
 
     # Configure Azure client
-    client = openai.AzureOpenAI(
-        api_key=api_key, azure_endpoint=endpoint, api_version=api_version
-    )
+    client = openai.AzureOpenAI(api_key=api_key, azure_endpoint=endpoint, api_version=api_version)
 
     # Prepare request
     model = config.get("model", config.get("deployment_name", "gpt-35-turbo"))
@@ -217,8 +200,7 @@ def _invoke_azure_openai(prompt: str, config: Dict[str, Any]) -> str:
     max_tokens = config.get("max_tokens", 1000)
 
     logger.debug(
-        f"🔧 Azure OpenAI config: model={model}, temp={temperature}, "
-        f"max_tokens={max_tokens}"
+        f"🔧 Azure OpenAI config: model={model}, temp={temperature}, max_tokens={max_tokens}"
     )
 
     # Make API call

dacp/json_parser.py

@@ -17,18 +17,18 @@ 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())
@@ -36,10 +36,10 @@ def extract_json_from_text(text: str) -> Optional[Dict[str, Any]]:
         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
+    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:
@@ -48,9 +48,9 @@ def extract_json_from_text(text: str) -> Optional[Dict[str, Any]]:
             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*```'
+    code_block_pattern = r"```(?:json)?\s*(\{.*?\})\s*```"
     matches = re.findall(code_block_pattern, text, re.DOTALL)
     for match in matches:
         try:
@@ -59,7 +59,7 @@ def extract_json_from_text(text: str) -> Optional[Dict[str, Any]]:
             return result
         except json.JSONDecodeError:
             continue
-    
+
     # Strategy 4: Find JSON after common prefixes
     prefixes = [
         "json response:",
@@ -69,40 +69,40 @@ def extract_json_from_text(text: str) -> Optional[Dict[str, Any]]:
         "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()
+            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, 
+    text: str,
     required_fields: Dict[str, Any],
-    optional_fields: Dict[str, Any] = None
+    optional_fields: Optional[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"]:
@@ -111,7 +111,7 @@ def create_fallback_response(
             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)
+            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)}")
@@ -121,45 +121,47 @@ def create_fallback_response(
         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],
+    response: Union[str, Dict[str, Any], BaseModel],
     target_model: type,
     required_fields: Dict[str, Any],
-    optional_fields: Dict[str, Any] = None
-) -> BaseModel:
+    optional_fields: Optional[Dict[str, Any]] = None,
+) -> Any:
     """
     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__}")
-    
+    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:
@@ -168,11 +170,11 @@ def robust_json_parse(
             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)
@@ -180,15 +182,11 @@ def robust_json_parse(
                 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
-        )
-        
+        fallback_data = create_fallback_response(response, required_fields, optional_fields)
+
         try:
             result = target_model(**fallback_data)
             logger.info("✅ Successfully created model from fallback data")
@@ -196,37 +194,37 @@ def robust_json_parse(
         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:
+def parse_with_fallback(response: Any, model_class: type, **field_defaults: Any) -> Any:
     """
     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'):
+    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) 
+
+    return robust_json_parse(response, model_class, required_fields, optional_fields)

dacp/logging_config.py

@@ -32,9 +32,7 @@ def setup_dacp_logging(
             log_format = "%(name)s - %(levelname)s - %(message)s"
     elif format_style == "detailed":
         if include_timestamp:
-            log_format = (
-                "%(asctime)s - %(name)s:%(lineno)d - %(levelname)s - %(message)s"
-            )
+            log_format = "%(asctime)s - %(name)s:%(lineno)d - %(levelname)s - %(message)s"
         else:
             log_format = "%(name)s:%(lineno)d - %(levelname)s - %(message)s"
     elif format_style == "emoji":

dacp/orchestrator.py

@@ -62,10 +62,7 @@ class Orchestrator:
             raise ValueError("Agent must inherit from dacp.Agent base class")
 
         self.agents[name] = agent
-        logger.info(
-            f"✅ Agent '{name}' registered successfully "
-            f"(type: {type(agent).__name__})"
-        )
+        logger.info(f"✅ Agent '{name}' registered successfully (type: {type(agent).__name__})")
         logger.debug(f"📊 Total registered agents: {len(self.agents)}")
 
     def unregister_agent(self, name: str) -> bool:
@@ -121,12 +118,12 @@ class Orchestrator:
             response = agent.handle_message(message)
 
             # Handle Pydantic models by converting to dict
-            if hasattr(response, 'model_dump'):
+            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__'):
+                if hasattr(response, "__dict__"):
                     response = response.__dict__
                 else:
                     response = {"result": str(response)}
@@ -138,9 +135,7 @@ class Orchestrator:
             # Check if agent requested tool execution
             if isinstance(response, dict) and "tool_request" in response:
                 logger.info(f"🔧 Agent '{agent_name}' requested tool execution")
-                response = self._handle_tool_request(
-                    agent_name, response["tool_request"]
-                )
+                response = self._handle_tool_request(agent_name, response["tool_request"])
 
             # Log the conversation
             self._log_conversation(agent_name, message, response, duration)
@@ -179,16 +174,11 @@ class Orchestrator:
             responses[agent_name] = self.send_message(agent_name, message)
 
         duration = time.time() - start_time
-        logger.info(
-            f"✅ Broadcast completed in {duration:.3f}s "
-            f"({len(responses)} responses)"
-        )
+        logger.info(f"✅ Broadcast completed in {duration:.3f}s ({len(responses)} responses)")
 
         return responses
 
-    def _handle_tool_request(
-        self, agent_name: str, tool_request: Dict[str, Any]
-    ) -> Dict[str, Any]:
+    def _handle_tool_request(self, agent_name: str, tool_request: Dict[str, Any]) -> Dict[str, Any]:
         """
         Handle tool execution request from an agent.
 
@@ -213,9 +203,7 @@ class Orchestrator:
             result = execute_tool(tool_name, tool_args)
             duration = time.time() - start_time
 
-            logger.info(
-                f"✅ Tool '{tool_name}' executed successfully in {duration:.3f}s"
-            )
+            logger.info(f"✅ Tool '{tool_name}' executed successfully in {duration:.3f}s")
             logger.debug(f"🔧 Tool result: {result}")
 
             return {"tool_result": {"name": tool_name, "result": result}}
@@ -254,9 +242,7 @@ class Orchestrator:
             self.conversation_history = self.conversation_history[-1000:]
             logger.debug("🗂️  Conversation history trimmed to 1000 entries")
 
-    def get_conversation_history(
-        self, limit: Optional[int] = None
-    ) -> List[Dict[str, Any]]:
+    def get_conversation_history(self, limit: Optional[int] = None) -> List[Dict[str, Any]]:
         """
         Get conversation history.
 
@@ -284,13 +270,9 @@ class Orchestrator:
             "agent_names": list(self.agents.keys()),
             "conversation_entries": len(self.conversation_history),
             "start_time": (
-                self.conversation_history[0]["timestamp"]
-                if self.conversation_history
-                else None
+                self.conversation_history[0]["timestamp"] if self.conversation_history else None
             ),
             "last_activity": (
-                self.conversation_history[-1]["timestamp"]
-                if self.conversation_history
-                else None
+                self.conversation_history[-1]["timestamp"] if self.conversation_history else None
             ),
         }

dacp/tools.py

@@ -43,9 +43,7 @@ def execute_tool(name: str, args: Dict[str, Any]) -> Dict[str, Any]:
     """
     if name not in TOOL_REGISTRY:
         available_tools = list(TOOL_REGISTRY.keys())
-        logger.error(
-            f"❌ Tool '{name}' not found. " f"Available tools: {available_tools}"
-        )
+        logger.error(f"❌ Tool '{name}' not found. Available tools: {available_tools}")
         raise ValueError(f"Tool '{name}' not found. Available tools: {available_tools}")
 
     logger.debug(f"🛠️  Executing tool '{name}' with args: {args}")

dacp/workflow.py

@@ -17,6 +17,7 @@ logger = logging.getLogger("dacp.workflow")
 
 class TaskStatus(Enum):
     """Task status enumeration."""
+
     PENDING = "pending"
     ASSIGNED = "assigned"
     IN_PROGRESS = "in_progress"
@@ -27,6 +28,7 @@ class TaskStatus(Enum):
 
 class TaskPriority(Enum):
     """Task priority enumeration."""
+
     LOW = 1
     NORMAL = 2
     HIGH = 3
@@ -36,6 +38,7 @@ class TaskPriority(Enum):
 @dataclass
 class Task:
     """Represents a task in the workflow system."""
+
     id: str
     type: str
     data: Dict[str, Any]
@@ -74,6 +77,7 @@ class Task:
 @dataclass
 class WorkflowRule:
     """Defines routing rules for agent-to-agent communication."""
+
     source_task_type: str
     target_agent: str
     target_task_type: str
@@ -85,7 +89,7 @@ class WorkflowRule:
 class TaskBoard:
     """Central task board for managing agent-to-agent tasks."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.tasks: Dict[str, Task] = {}
         self.agent_queues: Dict[str, List[str]] = {}
         self.completed_tasks: List[str] = []
@@ -98,11 +102,11 @@ class TaskBoard:
         source_agent: str,
         target_agent: Optional[str] = None,
         priority: TaskPriority = TaskPriority.NORMAL,
-        dependencies: List[str] = None,
+        dependencies: Optional[List[str]] = None,
     ) -> str:
         """Add a new task to the board."""
         task_id = str(uuid.uuid4())
-        
+
         task = Task(
             id=task_id,
             type=task_type,
@@ -145,7 +149,7 @@ class TaskBoard:
 
         # 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
 
@@ -153,10 +157,7 @@ class TaskBoard:
         return next_task
 
     def complete_task(
-        self, 
-        task_id: str, 
-        result: Dict[str, Any], 
-        trigger_rules: bool = True
+        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:
@@ -240,9 +241,7 @@ class TaskBoard:
                     priority=rule.priority,
                 )
 
-                logger.info(
-                    f"🔄 Workflow rule triggered: {completed_task.id} → {new_task_id}"
-                )
+                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."""
@@ -261,13 +260,15 @@ class TaskBoard:
         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,
-                })
+                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,
@@ -277,7 +278,7 @@ class TaskBoard:
 
     def get_workflow_summary(self) -> Dict[str, Any]:
         """Get overall workflow summary."""
-        status_counts = {}
+        status_counts: Dict[str, int] = {}
         for task in self.tasks.values():
             status = task.status.value
             status_counts[status] = status_counts.get(status, 0) + 1
@@ -285,9 +286,7 @@ class TaskBoard:
         return {
             "total_tasks": len(self.tasks),
             "status_counts": status_counts,
-            "agent_queues": {
-                agent: len(queue) for agent, queue in self.agent_queues.items()
-            },
+            "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),
         }
@@ -296,7 +295,7 @@ class TaskBoard:
 class WorkflowOrchestrator:
     """Enhanced orchestrator with workflow and agent-to-agent communication."""
 
-    def __init__(self, orchestrator):
+    def __init__(self, orchestrator: Any) -> None:
         """Initialize with a base orchestrator."""
         self.orchestrator = orchestrator
         self.task_board = TaskBoard()
@@ -358,7 +357,13 @@ class WorkflowOrchestrator:
 
                 if "error" in response:
                     self.task_board.fail_task(task.id, response["error"])
-                    results.append({"task_id": task.id, "status": "failed", "error": 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})
@@ -406,4 +411,4 @@ class WorkflowOrchestrator:
                 agent: self.task_board.get_agent_queue_status(agent)
                 for agent in self.orchestrator.agents.keys()
             },
-        } 
+        }