emdash-core 0.1.25__py3-none-any.whl → 0.1.37__py3-none-any.whl

emdash_core/agent/__init__.py

@@ -19,6 +19,9 @@ def __getattr__(name: str):
     elif name == "AgentRunner":
         from .runner import AgentRunner
         return AgentRunner
+    elif name == "SafeJSONEncoder":
+        from .runner import SafeJSONEncoder
+        return SafeJSONEncoder
     elif name == "ToolResult":
         from .tools.base import ToolResult
         return ToolResult
@@ -32,6 +35,7 @@ __all__ = [
     "AgentToolkit",
     "AgentSession",
     "AgentRunner",
+    "SafeJSONEncoder",
     "ToolResult",
     "ToolCategory",
 ]

emdash_core/agent/agents.py

@@ -2,16 +2,74 @@
 
 Allows users to define custom agent configurations with
 specialized system prompts and tool selections.
+
+Example agent file:
+```markdown
+---
+description: GitHub integration agent
+model: claude-sonnet-4-20250514
+tools: [grep, glob, read_file]
+mcp_servers:
+  github:
+    command: github-mcp-server
+    args: []
+    env:
+      GITHUB_TOKEN: ${GITHUB_TOKEN}
+    enabled: true
+  filesystem:
+    command: npx
+    args: [-y, "@anthropic/mcp-server-filesystem", "/tmp"]
+    enabled: false  # Disabled - won't be started
+---
+
+# System Prompt
+
+You are a GitHub integration specialist...
+```
 """
 
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional
 import re
 
+import yaml
+
 from ..utils.logger import log
 
 
+@dataclass
+class AgentMCPServerConfig:
+    """MCP server configuration for a custom agent.
+
+    Attributes:
+        name: Server name (key in mcp_servers dict)
+        command: Command to run the server
+        args: Arguments to pass to the command
+        env: Environment variables (supports ${VAR} syntax)
+        enabled: Whether this server is enabled (default: True)
+        timeout: Timeout in seconds for tool calls
+    """
+    name: str
+    command: str
+    args: list[str] = field(default_factory=list)
+    env: dict[str, str] = field(default_factory=dict)
+    enabled: bool = True
+    timeout: int = 30
+
+    @classmethod
+    def from_dict(cls, name: str, data: dict[str, Any]) -> "AgentMCPServerConfig":
+        """Create from dictionary parsed from YAML."""
+        return cls(
+            name=name,
+            command=data.get("command", ""),
+            args=data.get("args", []),
+            env=data.get("env", {}),
+            enabled=data.get("enabled", True),
+            timeout=data.get("timeout", 30),
+        )
+
+
 @dataclass
 class CustomAgent:
     """A custom agent configuration loaded from markdown.
@@ -19,16 +77,20 @@ class CustomAgent:
     Attributes:
         name: Agent name (from filename)
         description: Brief description
+        model: Model to use for this agent (optional, uses default if not set)
         system_prompt: Custom system prompt
         tools: List of tools to enable
+        mcp_servers: MCP server configurations for this agent
         examples: Example interactions
         file_path: Source file path
     """
 
     name: str
     description: str = ""
+    model: Optional[str] = None
     system_prompt: str = ""
     tools: list[str] = field(default_factory=list)
+    mcp_servers: list[AgentMCPServerConfig] = field(default_factory=list)
     examples: list[dict] = field(default_factory=list)
     file_path: Optional[Path] = None
 
@@ -121,46 +183,45 @@ def _parse_agent_file(file_path: Path) -> Optional[CustomAgent]:
     if system_prompt.startswith("# System Prompt"):
         system_prompt = system_prompt[len("# System Prompt") :].strip()
 
+    # Parse MCP servers from frontmatter
+    mcp_servers = []
+    mcp_servers_data = frontmatter.get("mcp_servers", {})
+    if isinstance(mcp_servers_data, dict):
+        for server_name, server_config in mcp_servers_data.items():
+            if isinstance(server_config, dict):
+                mcp_servers.append(
+                    AgentMCPServerConfig.from_dict(server_name, server_config)
+                )
+
     return CustomAgent(
         name=file_path.stem,
         description=frontmatter.get("description", ""),
+        model=frontmatter.get("model"),
         system_prompt=system_prompt,
         tools=frontmatter.get("tools", []),
+        mcp_servers=mcp_servers,
         examples=examples,
         file_path=file_path,
     )
 
 
 def _parse_frontmatter(frontmatter_str: str) -> dict:
-    """Parse YAML-like frontmatter.
+    """Parse YAML frontmatter.
 
-    Simple parser for key: value pairs.
+    Uses PyYAML for proper nested structure parsing.
 
     Args:
-        frontmatter_str: Frontmatter string
+        frontmatter_str: Frontmatter string (YAML format)
 
     Returns:
         Dict of parsed values
     """
-    result = {}
-
-    for line in frontmatter_str.strip().split("\n"):
-        if ":" not in line:
-            continue
-
-        key, value = line.split(":", 1)
-        key = key.strip()
-        value = value.strip()
-
-        # Parse list values
-        if value.startswith("[") and value.endswith("]"):
-            # Simple list parsing
-            items = value[1:-1].split(",")
-            result[key] = [item.strip().strip("'\"") for item in items if item.strip()]
-        else:
-            result[key] = value.strip("'\"")
-
-    return result
+    try:
+        result = yaml.safe_load(frontmatter_str)
+        return result if isinstance(result, dict) else {}
+    except yaml.YAMLError as e:
+        log.warning(f"Failed to parse frontmatter as YAML: {e}")
+        return {}
 
 
 def _parse_examples(examples_str: str) -> list[dict]:

emdash_core/agent/events.py

@@ -17,6 +17,10 @@ class EventType(Enum):
     TOOL_START = "tool_start"
     TOOL_RESULT = "tool_result"
 
+    # Sub-agent lifecycle
+    SUBAGENT_START = "subagent_start"
+    SUBAGENT_END = "subagent_end"
+
     # Agent thinking/progress
     THINKING = "thinking"
     PROGRESS = "progress"
@@ -24,10 +28,12 @@ class EventType(Enum):
     # Output
     RESPONSE = "response"
     PARTIAL_RESPONSE = "partial_response"
+    ASSISTANT_TEXT = "assistant_text"  # Intermediate text between tool calls
 
     # Interaction
     CLARIFICATION = "clarification"
     CLARIFICATION_RESPONSE = "clarification_response"
+    PLAN_MODE_REQUESTED = "plan_mode_requested"
     PLAN_SUBMITTED = "plan_submitted"
 
     # Errors
@@ -144,16 +150,23 @@ class AgentEventEmitter:
 
         return event
 
-    def emit_tool_start(self, name: str, args: dict[str, Any] | None = None) -> AgentEvent:
+    def emit_tool_start(
+        self,
+        name: str,
+        args: dict[str, Any] | None = None,
+        tool_id: str | None = None,
+    ) -> AgentEvent:
         """Convenience method to emit a tool start event.
 
         Args:
             name: Tool name
             args: Tool arguments
+            tool_id: Unique ID for this tool call (for matching with result)
         """
         return self.emit(EventType.TOOL_START, {
             "name": name,
             "args": args or {},
+            "tool_id": tool_id,
         })
 
     def emit_tool_result(
@@ -162,6 +175,7 @@ class AgentEventEmitter:
         success: bool,
         summary: str | None = None,
         data: dict[str, Any] | None = None,
+        tool_id: str | None = None,
     ) -> AgentEvent:
         """Convenience method to emit a tool result event.
 
@@ -170,12 +184,14 @@ class AgentEventEmitter:
             success: Whether the tool succeeded
             summary: Brief summary of the result
             data: Full result data (may be truncated by handlers)
+            tool_id: Unique ID for this tool call (for matching with start)
         """
         return self.emit(EventType.TOOL_RESULT, {
             "name": name,
             "success": success,
             "summary": summary,
             "data": data,
+            "tool_id": tool_id,
         })
 
     def emit_thinking(self, message: str) -> AgentEvent:
@@ -208,6 +224,14 @@ class AgentEventEmitter:
         event_type = EventType.RESPONSE if is_final else EventType.PARTIAL_RESPONSE
         return self.emit(event_type, {"content": content})
 
+    def emit_assistant_text(self, content: str) -> AgentEvent:
+        """Emit intermediate assistant text (shown between tool calls).
+
+        Args:
+            content: Text content from assistant (e.g., "Let me read the file...")
+        """
+        return self.emit(EventType.ASSISTANT_TEXT, {"content": content})
+
     def emit_clarification(
         self,
         question: str,
@@ -227,32 +251,30 @@ class AgentEventEmitter:
             "options": options,
         })
 
-    def emit_plan_submitted(
+    def emit_plan_mode_requested(
         self,
-        title: str,
-        summary: str,
-        files_to_modify: list[dict] | None = None,
-        implementation_steps: list[str] | None = None,
-        risks: list[str] | None = None,
-        testing_strategy: str | None = None,
+        reason: str,
     ) -> AgentEvent:
+        """Convenience method to emit a plan mode request event.
+
+        This is emitted when the agent calls enter_plan_mode tool,
+        requesting user consent to enter plan mode.
+
+        Args:
+            reason: Why the agent wants to enter plan mode
+        """
+        return self.emit(EventType.PLAN_MODE_REQUESTED, {
+            "reason": reason,
+        })
+
+    def emit_plan_submitted(self, plan: str) -> AgentEvent:
         """Convenience method to emit a plan submission event.
 
         Args:
-            title: Plan title
-            summary: Plan summary
-            files_to_modify: List of files with path, lines, changes
-            implementation_steps: Ordered implementation steps
-            risks: Potential risks or considerations
-            testing_strategy: How changes will be tested
+            plan: The implementation plan as markdown
         """
         return self.emit(EventType.PLAN_SUBMITTED, {
-            "title": title,
-            "summary": summary,
-            "files_to_modify": files_to_modify or [],
-            "implementation_steps": implementation_steps or [],
-            "risks": risks or [],
-            "testing_strategy": testing_strategy or "",
+            "plan": plan,
         })
 
     def emit_error(self, message: str, details: str | None = None) -> AgentEvent: