emdash-core 0.1.7__py3-none-any.whl

emdash_core/agent/context_manager.py

@@ -0,0 +1,140 @@
+"""Context length management for agent conversations."""
+
+from typing import Optional
+
+from ..core.config import get_config
+from ..utils.logger import log
+
+
+def estimate_tokens(text: str) -> int:
+    """Estimate token count from text.
+
+    Uses ~4 characters per token as a rough estimate.
+    This is conservative for English text and code.
+
+    Args:
+        text: Text to estimate tokens for
+
+    Returns:
+        Estimated token count
+    """
+    if not text:
+        return 0
+    return len(text) // 4
+
+
+def truncate_tool_output(output: str, max_tokens: Optional[int] = None) -> str:
+    """Truncate tool output to stay within token limit.
+
+    Args:
+        output: Tool output string (usually JSON)
+        max_tokens: Maximum tokens (uses config default if None)
+
+    Returns:
+        Truncated output with indicator if truncated
+    """
+    config = get_config()
+    max_tokens = max_tokens or config.agent.tool_max_output_tokens
+    max_chars = max_tokens * 4  # Reverse the ~4 chars/token estimate
+
+    if len(output) <= max_chars:
+        return output
+
+    # Truncate and add indicator
+    truncated = output[: max_chars - 150]  # Leave room for truncation message
+    chars_removed = len(output) - len(truncated)
+    lines_removed = output[max_chars - 150 :].count("\n")
+
+    truncation_msg = (
+        f"\n\n[OUTPUT TRUNCATED: ~{lines_removed} lines omitted, "
+        f"{chars_removed} chars removed to fit {max_tokens} token limit]"
+    )
+
+    log.warning(
+        "Truncated tool output from {} to {} chars (~{} tokens)",
+        len(output),
+        len(truncated),
+        max_tokens,
+    )
+
+    return truncated + truncation_msg
+
+
+def reduce_context_for_retry(
+    messages: list[dict],
+    keep_recent: int = 4,
+) -> list[dict]:
+    """Reduce context by removing old messages.
+
+    Keeps the first user message and the most recent messages.
+
+    Args:
+        messages: Current messages list
+        keep_recent: Number of recent messages to keep
+
+    Returns:
+        Reduced messages list
+    """
+    if len(messages) <= keep_recent + 1:
+        return messages  # Can't reduce further
+
+    # Always keep first message (initial user query)
+    first_msg = messages[0]
+
+    # Keep the most recent messages
+    recent_msgs = messages[-keep_recent:]
+
+    reduced = [first_msg] + recent_msgs
+
+    log.info(
+        "Reduced context from {} to {} messages for retry",
+        len(messages),
+        len(reduced),
+    )
+
+    return reduced
+
+
+def is_context_overflow_error(exc: Exception) -> bool:
+    """Check if an exception is a context length overflow error.
+
+    Handles different error formats from various providers:
+    - OpenAI: "context_length_exceeded" code
+    - Anthropic: "prompt is too long" message
+    - Fireworks: Similar to OpenAI format
+
+    Args:
+        exc: Exception to check
+
+    Returns:
+        True if this is a context overflow error
+    """
+    error_str = str(exc).lower()
+
+    # Check common error patterns
+    overflow_patterns = [
+        "context_length_exceeded",
+        "context length",
+        "maximum context length",
+        "prompt is too long",
+        "too many tokens",
+        "token limit",
+        "exceeds the model's maximum",
+        "max_tokens",
+    ]
+
+    for pattern in overflow_patterns:
+        if pattern in error_str:
+            return True
+
+    # Check for specific error codes
+    if hasattr(exc, "code"):
+        if exc.code == "context_length_exceeded":
+            return True
+
+    # Check HTTP status (400 often used for this)
+    if hasattr(exc, "status_code"):
+        if exc.status_code == 400 and any(p in error_str for p in overflow_patterns):
+            return True
+
+    return False

emdash_core/agent/events.py

@@ -0,0 +1,338 @@
+"""Unified event stream for agent operations.
+
+This module provides a centralized event system that both CLI and UI can consume,
+ensuring consistent message handling across interfaces.
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Any, Protocol
+
+
+class EventType(Enum):
+    """Types of events emitted by agents."""
+
+    # Tool lifecycle
+    TOOL_START = "tool_start"
+    TOOL_RESULT = "tool_result"
+
+    # Agent thinking/progress
+    THINKING = "thinking"
+    PROGRESS = "progress"
+
+    # Output
+    RESPONSE = "response"
+    PARTIAL_RESPONSE = "partial_response"
+
+    # Interaction
+    CLARIFICATION = "clarification"
+    CLARIFICATION_RESPONSE = "clarification_response"
+
+    # Errors
+    ERROR = "error"
+    WARNING = "warning"
+
+    # Session
+    SESSION_START = "session_start"
+    SESSION_END = "session_end"
+
+    # Context
+    CONTEXT_FRAME = "context_frame"
+
+
+@dataclass
+class AgentEvent:
+    """A single event emitted by an agent.
+
+    Attributes:
+        type: The type of event
+        data: Event-specific data payload
+        timestamp: When the event occurred
+        agent_name: Optional name of the agent that emitted this event
+    """
+    type: EventType
+    data: dict[str, Any]
+    timestamp: datetime = field(default_factory=datetime.now)
+    agent_name: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "type": self.type.value,
+            "data": self.data,
+            "timestamp": self.timestamp.isoformat(),
+            "agent_name": self.agent_name,
+        }
+
+
+class EventHandler(Protocol):
+    """Protocol for event handlers."""
+
+    def handle(self, event: AgentEvent) -> None:
+        """Handle an emitted event."""
+        ...
+
+
+class AgentEventEmitter:
+    """Emits and stores agent events for consumption by handlers.
+
+    This is the central hub for the event stream. Agents emit events here,
+    and handlers (CLI Rich renderer, JSON streamer, etc.) subscribe to receive them.
+
+    Example:
+        emitter = AgentEventEmitter()
+        emitter.add_handler(RichConsoleHandler())
+
+        # In agent code:
+        emitter.emit(EventType.TOOL_START, {"name": "semantic_search", "args": {...}})
+        result = execute_tool(...)
+        emitter.emit(EventType.TOOL_RESULT, {"name": "semantic_search", "success": True})
+    """
+
+    def __init__(self, agent_name: str | None = None):
+        """Initialize the emitter.
+
+        Args:
+            agent_name: Optional name to tag all events from this emitter
+        """
+        self._handlers: list[EventHandler] = []
+        self._events: list[AgentEvent] = []
+        self._agent_name = agent_name
+
+    def add_handler(self, handler: EventHandler) -> None:
+        """Add a handler to receive events.
+
+        Args:
+            handler: Handler that implements the EventHandler protocol
+        """
+        self._handlers.append(handler)
+
+    def remove_handler(self, handler: EventHandler) -> None:
+        """Remove a handler.
+
+        Args:
+            handler: Handler to remove
+        """
+        if handler in self._handlers:
+            self._handlers.remove(handler)
+
+    def emit(self, event_type: EventType, data: dict[str, Any] | None = None) -> AgentEvent:
+        """Emit an event to all handlers.
+
+        Args:
+            event_type: Type of event to emit
+            data: Event-specific data payload
+
+        Returns:
+            The created AgentEvent
+        """
+        event = AgentEvent(
+            type=event_type,
+            data=data or {},
+            agent_name=self._agent_name,
+        )
+        self._events.append(event)
+
+        for handler in self._handlers:
+            try:
+                handler.handle(event)
+            except Exception:
+                # Don't let handler errors break the agent
+                pass
+
+        return event
+
+    def emit_tool_start(self, name: str, args: dict[str, Any] | None = None) -> AgentEvent:
+        """Convenience method to emit a tool start event.
+
+        Args:
+            name: Tool name
+            args: Tool arguments
+        """
+        return self.emit(EventType.TOOL_START, {
+            "name": name,
+            "args": args or {},
+        })
+
+    def emit_tool_result(
+        self,
+        name: str,
+        success: bool,
+        summary: str | None = None,
+        data: dict[str, Any] | None = None,
+    ) -> AgentEvent:
+        """Convenience method to emit a tool result event.
+
+        Args:
+            name: Tool name
+            success: Whether the tool succeeded
+            summary: Brief summary of the result
+            data: Full result data (may be truncated by handlers)
+        """
+        return self.emit(EventType.TOOL_RESULT, {
+            "name": name,
+            "success": success,
+            "summary": summary,
+            "data": data,
+        })
+
+    def emit_thinking(self, message: str) -> AgentEvent:
+        """Convenience method to emit a thinking/progress message.
+
+        Args:
+            message: What the agent is thinking/doing
+        """
+        return self.emit(EventType.THINKING, {"message": message})
+
+    def emit_progress(self, message: str, percent: float | None = None) -> AgentEvent:
+        """Convenience method to emit a progress update.
+
+        Args:
+            message: Progress message
+            percent: Optional completion percentage (0-100)
+        """
+        return self.emit(EventType.PROGRESS, {
+            "message": message,
+            "percent": percent,
+        })
+
+    def emit_response(self, content: str, is_final: bool = True) -> AgentEvent:
+        """Convenience method to emit a response.
+
+        Args:
+            content: Response content (usually markdown)
+            is_final: Whether this is the final response
+        """
+        event_type = EventType.RESPONSE if is_final else EventType.PARTIAL_RESPONSE
+        return self.emit(event_type, {"content": content})
+
+    def emit_clarification(
+        self,
+        question: str,
+        context: str | None = None,
+        options: list[str] | None = None,
+    ) -> AgentEvent:
+        """Convenience method to emit a clarification request.
+
+        Args:
+            question: The question to ask
+            context: Why we're asking
+            options: Suggested answers
+        """
+        return self.emit(EventType.CLARIFICATION, {
+            "question": question,
+            "context": context,
+            "options": options,
+        })
+
+    def emit_error(self, message: str, details: str | None = None) -> AgentEvent:
+        """Convenience method to emit an error.
+
+        Args:
+            message: Error message
+            details: Additional details (stack trace, etc.)
+        """
+        return self.emit(EventType.ERROR, {
+            "message": message,
+            "details": details,
+        })
+
+    def emit_start(self, goal: str, **kwargs) -> AgentEvent:
+        """Convenience method to emit a session start event.
+
+        Args:
+            goal: The goal/query for this session
+            **kwargs: Additional data to include
+        """
+        return self.emit(EventType.SESSION_START, {
+            "goal": goal,
+            **kwargs,
+        })
+
+    def emit_end(self, success: bool = True, **kwargs) -> AgentEvent:
+        """Convenience method to emit a session end event.
+
+        Args:
+            success: Whether the session completed successfully
+            **kwargs: Additional data to include
+        """
+        return self.emit(EventType.SESSION_END, {
+            "success": success,
+            **kwargs,
+        })
+
+    def emit_context_frame(
+        self,
+        adding: dict[str, Any] | None = None,
+        reading: dict[str, Any] | None = None,
+    ) -> AgentEvent:
+        """Convenience method to emit a context frame update.
+
+        Args:
+            adding: What's being added to context (modified_files, exploration_steps, tokens)
+            reading: What's being read from context (items with scores, tokens)
+        """
+        return self.emit(EventType.CONTEXT_FRAME, {
+            "adding": adding or {},
+            "reading": reading or {},
+        })
+
+    def emit_message_start(self) -> AgentEvent:
+        """Convenience method to emit message start event."""
+        self._accumulated_content = ""
+        return self.emit(EventType.PARTIAL_RESPONSE, {"status": "start"})
+
+    def emit_message_delta(self, content: str) -> AgentEvent:
+        """Convenience method to emit message delta (streaming content).
+
+        Args:
+            content: The content chunk to stream
+        """
+        if hasattr(self, '_accumulated_content'):
+            self._accumulated_content += content
+        return self.emit(EventType.PARTIAL_RESPONSE, {"content": content})
+
+    def emit_message_end(self) -> AgentEvent:
+        """Convenience method to emit message end event with accumulated content."""
+        content = getattr(self, '_accumulated_content', "")
+        return self.emit(EventType.RESPONSE, {"content": content})
+
+    def get_events(self) -> list[AgentEvent]:
+        """Get all events emitted so far.
+
+        Returns:
+            Copy of the events list
+        """
+        return self._events.copy()
+
+    def clear_events(self) -> None:
+        """Clear the events history."""
+        self._events.clear()
+
+
+# Default no-op emitter for backwards compatibility
+class NullEmitter(AgentEventEmitter):
+    """An emitter that does nothing - for backwards compatibility."""
+
+    def emit(self, event_type: EventType, data: dict[str, Any] | None = None) -> AgentEvent:
+        """Create event but don't store or dispatch it."""
+        return AgentEvent(type=event_type, data=data or {}, agent_name=self._agent_name)
+
+
+# Global default emitter (can be replaced)
+_default_emitter: AgentEventEmitter | None = None
+
+
+def get_default_emitter() -> AgentEventEmitter:
+    """Get the default global emitter."""
+    global _default_emitter
+    if _default_emitter is None:
+        _default_emitter = NullEmitter()
+    return _default_emitter
+
+
+def set_default_emitter(emitter: AgentEventEmitter) -> None:
+    """Set the default global emitter."""
+    global _default_emitter
+    _default_emitter = emitter

emdash_core/agent/handlers.py

@@ -0,0 +1,224 @@
+"""Event handlers for agent output.
+
+Provides various handler implementations for routing agent events
+to different destinations.
+"""
+
+import json
+import sys
+from typing import IO, Optional
+
+from rich.console import Console
+from rich.live import Live
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.spinner import Spinner
+from rich.text import Text
+
+from .events import AgentEvent, AgentEventEmitter, EventType
+
+
+class RichConsoleHandler(AgentEventEmitter):
+    """Handler that renders events to the console using Rich.
+
+    Provides a nice interactive display with spinners, panels,
+    and formatted output.
+    """
+
+    def __init__(
+        self,
+        agent_name: str = "Agent",
+        console: Optional[Console] = None,
+        show_thinking: bool = True,
+    ):
+        """Initialize the console handler.
+
+        Args:
+            agent_name: Name to display for the agent
+            console: Rich console instance
+            show_thinking: Whether to show thinking blocks
+        """
+        super().__init__(agent_name)
+        self.console = console or Console()
+        self.show_thinking = show_thinking
+        self._current_message = ""
+        self._current_thinking = ""
+        self._in_message = False
+        self._in_thinking = False
+
+    def _handle(self, event: AgentEvent) -> None:
+        """Handle an event by rendering to console."""
+        if event.type == EventType.AGENT_START:
+            goal = event.data.get("goal", "")
+            self.console.print(
+                Panel(
+                    f"[bold cyan]{self.agent_name}[/bold cyan] starting...\n"
+                    f"[dim]Goal: {goal}[/dim]",
+                    border_style="cyan",
+                )
+            )
+
+        elif event.type == EventType.AGENT_END:
+            success = event.data.get("success", True)
+            if success:
+                self.console.print("[green]Agent completed successfully[/green]")
+            else:
+                self.console.print("[red]Agent finished with errors[/red]")
+
+        elif event.type == EventType.AGENT_ERROR:
+            error = event.data.get("error", "Unknown error")
+            self.console.print(f"[red bold]Error:[/red bold] {error}")
+
+        elif event.type == EventType.MESSAGE_START:
+            self._in_message = True
+            self._current_message = ""
+
+        elif event.type == EventType.MESSAGE_DELTA:
+            content = event.data.get("content", "")
+            self._current_message += content
+            # Print incrementally
+            self.console.print(content, end="")
+
+        elif event.type == EventType.MESSAGE_END:
+            self._in_message = False
+            if self._current_message:
+                self.console.print()  # Newline
+
+        elif event.type == EventType.TOOL_START:
+            name = event.data.get("name", "tool")
+            args = event.data.get("args", {})
+            args_str = ", ".join(f"{k}={v!r}" for k, v in list(args.items())[:3])
+            self.console.print(f"[dim]> {name}({args_str})[/dim]")
+
+        elif event.type == EventType.TOOL_RESULT:
+            name = event.data.get("name", "tool")
+            success = event.data.get("success", True)
+            summary = event.data.get("summary", "")
+            if success:
+                self.console.print(f"[green]  {name}: {summary}[/green]")
+            else:
+                self.console.print(f"[red]  {name} failed: {summary}[/red]")
+
+        elif event.type == EventType.THINKING_START:
+            if self.show_thinking:
+                self._in_thinking = True
+                self._current_thinking = ""
+                self.console.print("[dim italic]Thinking...[/dim italic]")
+
+        elif event.type == EventType.THINKING_DELTA:
+            if self.show_thinking:
+                content = event.data.get("content", "")
+                self._current_thinking += content
+
+        elif event.type == EventType.THINKING_END:
+            if self.show_thinking and self._current_thinking:
+                # Optionally show thinking summary
+                self._in_thinking = False
+
+
+class JSONStreamHandler(AgentEventEmitter):
+    """Handler that outputs events as JSON lines.
+
+    Suitable for piping to other processes or web clients.
+    """
+
+    def __init__(
+        self,
+        agent_name: str = "Agent",
+        output: IO = sys.stdout,
+    ):
+        """Initialize the JSON stream handler.
+
+        Args:
+            agent_name: Name for the agent
+            output: Output stream (default stdout)
+        """
+        super().__init__(agent_name)
+        self.output = output
+
+    def _handle(self, event: AgentEvent) -> None:
+        """Handle an event by writing JSON."""
+        try:
+            json_line = json.dumps(event.to_dict())
+            self.output.write(json_line + "\n")
+            self.output.flush()
+        except Exception:
+            pass  # Don't break on serialization errors
+
+
+class CollectingHandler(AgentEventEmitter):
+    """Handler that collects all events for later processing.
+
+    Useful for testing or batch processing.
+    """
+
+    def __init__(self, agent_name: str = "Agent"):
+        """Initialize the collecting handler."""
+        super().__init__(agent_name)
+        self.events: list[AgentEvent] = []
+
+    def _handle(self, event: AgentEvent) -> None:
+        """Collect the event."""
+        self.events.append(event)
+
+    def clear(self) -> None:
+        """Clear collected events."""
+        self.events.clear()
+
+    def get_events(self, event_type: Optional[EventType] = None) -> list[AgentEvent]:
+        """Get collected events, optionally filtered by type.
+
+        Args:
+            event_type: Optional type to filter by
+
+        Returns:
+            List of events
+        """
+        if event_type is None:
+            return list(self.events)
+        return [e for e in self.events if e.type == event_type]
+
+
+class CompositeHandler(AgentEventEmitter):
+    """Handler that forwards events to multiple handlers.
+
+    Allows combining multiple output destinations.
+    """
+
+    def __init__(
+        self,
+        agent_name: str = "Agent",
+        handlers: Optional[list[AgentEventEmitter]] = None,
+    ):
+        """Initialize the composite handler.
+
+        Args:
+            agent_name: Name for the agent
+            handlers: List of handlers to forward to
+        """
+        super().__init__(agent_name)
+        self.handlers = handlers or []
+
+    def add_handler(self, handler: AgentEventEmitter) -> None:
+        """Add a handler.
+
+        Args:
+            handler: Handler to add
+        """
+        self.handlers.append(handler)
+
+    def remove_handler(self, handler: AgentEventEmitter) -> None:
+        """Remove a handler.
+
+        Args:
+            handler: Handler to remove
+        """
+        self.handlers = [h for h in self.handlers if h != handler]
+
+    def _handle(self, event: AgentEvent) -> None:
+        """Forward event to all handlers."""
+        for handler in self.handlers:
+            try:
+                handler.emit(event)
+            except Exception:
+                pass  # Don't let one handler break others