dacp 0.3.2__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

@@ -0,0 +1,230 @@
+"""
+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: 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"]:
+            # 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[str, Any], BaseModel],
+    target_model: type,
+    required_fields: Dict[str, Any],
+    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__}"
+    )
+
+    # 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: 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"):
+        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/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:
@@ -120,6 +117,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}")
@@ -127,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)
@@ -168,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.
 
@@ -202,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}}
@@ -229,6 +228,7 @@ class Orchestrator:
         entry = {
             "timestamp": time.time(),
             "session_id": self.session_id,
+            "agent": agent_name,
             "agent_name": agent_name,
             "message": message,
             "response": response,
@@ -242,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.
 
@@ -272,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}")