code-puppy 0.0.354__py3-none-any.whl → 0.0.356__py3-none-any.whl

code_puppy/agents/__init__.py

@@ -12,6 +12,7 @@ from .agent_manager import (
     refresh_agents,
     set_current_agent,
 )
+from .subagent_stream_handler import subagent_stream_handler
 
 __all__ = [
     "get_available_agents",
@@ -20,4 +21,5 @@ __all__ = [
     "load_agent",
     "get_agent_descriptions",
     "refresh_agents",
+    "subagent_stream_handler",
 ]

code_puppy/agents/event_stream_handler.py

@@ -1,5 +1,7 @@
 """Event stream handler for processing streaming events from agent runs."""
 
+import asyncio
+import logging
 from collections.abc import AsyncIterable
 from typing import Any, Optional
 
@@ -16,8 +18,35 @@ from rich.console import Console
 from rich.markup import escape
 from rich.text import Text
 
-from code_puppy.config import get_banner_color
+from code_puppy.config import get_banner_color, get_subagent_verbose
 from code_puppy.messaging.spinner import pause_all_spinners, resume_all_spinners
+from code_puppy.tools.subagent_context import is_subagent
+
+logger = logging.getLogger(__name__)
+
+
+def _fire_stream_event(event_type: str, event_data: Any) -> None:
+    """Fire a stream event callback asynchronously (non-blocking).
+
+    Args:
+        event_type: Type of the event (e.g., 'part_start', 'part_delta', 'part_end')
+        event_data: Data associated with the event
+    """
+    try:
+        from code_puppy import callbacks
+        from code_puppy.messaging import get_session_context
+
+        agent_session_id = get_session_context()
+
+        # Use create_task to fire callback without blocking
+        asyncio.create_task(
+            callbacks.on_stream_event(event_type, event_data, agent_session_id)
+        )
+    except ImportError:
+        logger.debug("callbacks or messaging module not available for stream event")
+    except Exception as e:
+        logger.debug(f"Error firing stream event callback: {e}")
+
 
 # Module-level console for streaming output
 # Set via set_streaming_console() to share console with spinner
@@ -47,6 +76,15 @@ def get_streaming_console() -> Console:
     return Console()
 
 
+def _should_suppress_output() -> bool:
+    """Check if sub-agent output should be suppressed.
+
+    Returns:
+        True if we're in a sub-agent context and verbose mode is disabled.
+    """
+    return is_subagent() and not get_subagent_verbose()
+
+
 async def event_stream_handler(
     ctx: RunContext,
     events: AsyncIterable[Any],
@@ -60,6 +98,12 @@ async def event_stream_handler(
         ctx: The run context.
         events: Async iterable of streaming events (PartStartEvent, PartDeltaEvent, etc.).
     """
+    # If we're in a sub-agent and verbose mode is disabled, silently consume events
+    if _should_suppress_output():
+        async for _ in events:
+            pass  # Just consume events without rendering
+        return
+
     import time
 
     from termflow import Parser as TermflowParser
@@ -121,6 +165,16 @@ async def event_stream_handler(
     async for event in events:
         # PartStartEvent - register the part but defer banner until content arrives
         if isinstance(event, PartStartEvent):
+            # Fire stream event callback for part_start
+            _fire_stream_event(
+                "part_start",
+                {
+                    "index": event.index,
+                    "part_type": type(event.part).__name__,
+                    "part": event.part,
+                },
+            )
+
             part = event.part
             if isinstance(part, ThinkingPart):
                 streaming_parts.add(event.index)
@@ -156,6 +210,16 @@ async def event_stream_handler(
 
         # PartDeltaEvent - stream the content as it arrives
         elif isinstance(event, PartDeltaEvent):
+            # Fire stream event callback for part_delta
+            _fire_stream_event(
+                "part_delta",
+                {
+                    "index": event.index,
+                    "delta_type": type(event.delta).__name__,
+                    "delta": event.delta,
+                },
+            )
+
             if event.index in streaming_parts:
                 delta = event.delta
                 if isinstance(delta, (TextPartDelta, ThinkingPartDelta)):
@@ -208,6 +272,15 @@ async def event_stream_handler(
 
         # PartEndEvent - finish the streaming with a newline
         elif isinstance(event, PartEndEvent):
+            # Fire stream event callback for part_end
+            _fire_stream_event(
+                "part_end",
+                {
+                    "index": event.index,
+                    "next_part_kind": getattr(event, "next_part_kind", None),
+                },
+            )
+
             if event.index in streaming_parts:
                 # For text parts, finalize termflow rendering
                 if event.index in text_parts:

code_puppy/agents/subagent_stream_handler.py

@@ -0,0 +1,276 @@
+"""Silenced event stream handler for sub-agents.
+
+This handler suppresses all console output but still:
+- Updates SubAgentConsoleManager with status/metrics
+- Fires stream_event callbacks for the frontend emitter plugin
+- Tracks tool calls, tokens, and status changes
+
+Usage:
+    >>> from code_puppy.agents.subagent_stream_handler import subagent_stream_handler
+    >>> # In agent run:
+    >>> await subagent_stream_handler(ctx, events, session_id="my-session-123")
+"""
+
+import asyncio
+import logging
+from collections.abc import AsyncIterable
+from typing import Any, Optional
+
+from pydantic_ai import PartDeltaEvent, PartEndEvent, PartStartEvent, RunContext
+from pydantic_ai.messages import (
+    TextPart,
+    TextPartDelta,
+    ThinkingPart,
+    ThinkingPartDelta,
+    ToolCallPart,
+    ToolCallPartDelta,
+)
+
+logger = logging.getLogger(__name__)
+
+
+# =============================================================================
+# Callback Helper
+# =============================================================================
+
+
+def _fire_callback(event_type: str, event_data: Any, session_id: Optional[str]) -> None:
+    """Fire stream_event callback non-blocking.
+
+    Schedules the callback to run asynchronously without waiting for it.
+    Silently ignores errors if no event loop is running or if the callback
+    system is unavailable.
+
+    Args:
+        event_type: Type of the event ('part_start', 'part_delta', 'part_end')
+        event_data: Dictionary containing event-specific data
+        session_id: Optional session ID for the sub-agent
+    """
+    try:
+        from code_puppy import callbacks
+
+        loop = asyncio.get_running_loop()
+        loop.create_task(callbacks.on_stream_event(event_type, event_data, session_id))
+    except RuntimeError:
+        # No event loop running - this can happen during shutdown
+        logger.debug("No event loop available for stream event callback")
+    except ImportError:
+        # Callbacks module not available
+        logger.debug("Callbacks module not available for stream event")
+    except Exception as e:
+        # Don't let callback errors break the stream handler
+        logger.debug(f"Error firing stream event callback: {e}")
+
+
+# =============================================================================
+# Token Estimation
+# =============================================================================
+
+
+def _estimate_tokens(content: str) -> int:
+    """Estimate token count from content string.
+
+    Uses a rough heuristic: ~4 characters per token for English text.
+    This is a ballpark estimate - actual tokenization varies by model.
+
+    Args:
+        content: The text content to estimate tokens for
+
+    Returns:
+        Estimated token count (minimum 1 for non-empty content)
+    """
+    if not content:
+        return 0
+    # Rough estimate: 4 chars = 1 token, minimum 1 for any content
+    return max(1, len(content) // 4)
+
+
+# =============================================================================
+# Main Handler
+# =============================================================================
+
+
+async def subagent_stream_handler(
+    ctx: RunContext,
+    events: AsyncIterable[Any],
+    session_id: Optional[str] = None,
+) -> None:
+    """Silent event stream handler for sub-agents.
+
+    Processes streaming events without producing any console output.
+    Updates the SubAgentConsoleManager with status and metrics, and fires
+    stream_event callbacks for any registered listeners.
+
+    Args:
+        ctx: The pydantic-ai run context
+        events: Async iterable of streaming events (PartStartEvent,
+                PartDeltaEvent, PartEndEvent)
+        session_id: Session ID of the sub-agent for console manager updates.
+                   If None, falls back to get_session_context().
+    """
+    # Late import to avoid circular dependencies
+    from code_puppy.messaging import get_session_context
+    from code_puppy.messaging.subagent_console import SubAgentConsoleManager
+
+    manager = SubAgentConsoleManager.get_instance()
+
+    # Resolve session_id, falling back to context if not provided
+    effective_session_id = session_id or get_session_context()
+
+    # Metrics tracking
+    token_count = 0
+    tool_call_count = 0
+    active_tool_parts: set[int] = set()  # Track active tool call indices
+
+    async for event in events:
+        try:
+            await _handle_event(
+                event=event,
+                manager=manager,
+                session_id=effective_session_id,
+                token_count=token_count,
+                tool_call_count=tool_call_count,
+                active_tool_parts=active_tool_parts,
+            )
+
+            # Update metrics from returned values
+            # (we need to track these at this level since they're modified in _handle_event)
+            if isinstance(event, PartStartEvent):
+                if isinstance(event.part, ToolCallPart):
+                    tool_call_count += 1
+                    active_tool_parts.add(event.index)
+
+            elif isinstance(event, PartDeltaEvent):
+                delta = event.delta
+                if isinstance(delta, (TextPartDelta, ThinkingPartDelta)):
+                    if delta.content_delta:
+                        token_count += _estimate_tokens(delta.content_delta)
+
+            elif isinstance(event, PartEndEvent):
+                active_tool_parts.discard(event.index)
+
+        except Exception as e:
+            # Log but don't crash on event handling errors
+            logger.debug(f"Error handling stream event: {e}")
+            continue
+
+
+async def _handle_event(
+    event: Any,
+    manager: Any,  # SubAgentConsoleManager
+    session_id: Optional[str],
+    token_count: int,
+    tool_call_count: int,
+    active_tool_parts: set[int],
+) -> None:
+    """Handle a single streaming event.
+
+    Updates the console manager and fires callbacks for each event type.
+
+    Args:
+        event: The streaming event to handle
+        manager: SubAgentConsoleManager instance
+        session_id: Session ID for updates
+        token_count: Current token count
+        tool_call_count: Current tool call count
+        active_tool_parts: Set of active tool call indices
+    """
+    if session_id is None:
+        # Can't update manager without session_id
+        logger.debug("No session_id available for stream event")
+        return
+
+    # -------------------------------------------------------------------------
+    # PartStartEvent - Track new parts and update status
+    # -------------------------------------------------------------------------
+    if isinstance(event, PartStartEvent):
+        part = event.part
+        event_data = {
+            "index": event.index,
+            "part_type": type(part).__name__,
+        }
+
+        if isinstance(part, ThinkingPart):
+            manager.update_agent(session_id, status="thinking")
+            event_data["content"] = getattr(part, "content", None)
+
+        elif isinstance(part, TextPart):
+            manager.update_agent(session_id, status="running")
+            event_data["content"] = getattr(part, "content", None)
+
+        elif isinstance(part, ToolCallPart):
+            # tool_call_count is updated in the main handler
+            manager.update_agent(
+                session_id,
+                status="tool_calling",
+                tool_call_count=tool_call_count + 1,  # +1 for this new one
+                current_tool=part.tool_name,
+            )
+            event_data["tool_name"] = part.tool_name
+            event_data["tool_call_id"] = getattr(part, "tool_call_id", None)
+
+        _fire_callback("part_start", event_data, session_id)
+
+    # -------------------------------------------------------------------------
+    # PartDeltaEvent - Track content deltas and update metrics
+    # -------------------------------------------------------------------------
+    elif isinstance(event, PartDeltaEvent):
+        delta = event.delta
+        event_data = {
+            "index": event.index,
+            "delta_type": type(delta).__name__,
+        }
+
+        if isinstance(delta, TextPartDelta):
+            content_delta = delta.content_delta
+            if content_delta:
+                # Token count is updated in main handler
+                new_token_count = token_count + _estimate_tokens(content_delta)
+                manager.update_agent(session_id, token_count=new_token_count)
+                event_data["content_delta"] = content_delta
+
+        elif isinstance(delta, ThinkingPartDelta):
+            content_delta = delta.content_delta
+            if content_delta:
+                new_token_count = token_count + _estimate_tokens(content_delta)
+                manager.update_agent(session_id, token_count=new_token_count)
+                event_data["content_delta"] = content_delta
+
+        elif isinstance(delta, ToolCallPartDelta):
+            # Tool call deltas might have partial args
+            event_data["args_delta"] = getattr(delta, "args_delta", None)
+            event_data["tool_name_delta"] = getattr(delta, "tool_name_delta", None)
+
+        _fire_callback("part_delta", event_data, session_id)
+
+    # -------------------------------------------------------------------------
+    # PartEndEvent - Track part completion and update status
+    # -------------------------------------------------------------------------
+    elif isinstance(event, PartEndEvent):
+        event_data = {
+            "index": event.index,
+            "next_part_kind": getattr(event, "next_part_kind", None),
+        }
+
+        # If this was a tool call part ending, check if we should reset status
+        if event.index in active_tool_parts:
+            # Remove this index from active parts (done in main handler)
+            # If no more active tool parts after removal, reset to running
+            remaining_active = active_tool_parts - {event.index}
+            if not remaining_active:
+                manager.update_agent(
+                    session_id,
+                    current_tool=None,
+                    status="running",
+                )
+
+        _fire_callback("part_end", event_data, session_id)
+
+
+# =============================================================================
+# Exports
+# =============================================================================
+
+__all__ = [
+    "subagent_stream_handler",
+]

code_puppy/api/__init__.py

@@ -0,0 +1,13 @@
+"""Code Puppy REST API module.
+
+This module provides a FastAPI-based REST API for Code Puppy configuration,
+sessions, commands, and real-time WebSocket communication.
+
+Exports:
+    create_app: Factory function to create the FastAPI application
+    main: Entry point to run the server
+"""
+
+from code_puppy.api.app import create_app
+
+__all__ = ["create_app"]

code_puppy/api/app.py

@@ -0,0 +1,92 @@
+"""FastAPI application factory for Code Puppy API."""
+
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, HTMLResponse
+
+
+def create_app() -> FastAPI:
+    """Create and configure the FastAPI application."""
+    app = FastAPI(
+        title="Code Puppy API",
+        description="REST API and Interactive Terminal for Code Puppy",
+        version="1.0.0",
+        docs_url="/docs",
+        redoc_url="/redoc",
+    )
+
+    # CORS middleware for frontend access
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],  # Local/trusted
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Include routers
+    from code_puppy.api.routers import agents, commands, config, sessions
+
+    app.include_router(config.router, prefix="/api/config", tags=["config"])
+    app.include_router(commands.router, prefix="/api/commands", tags=["commands"])
+    app.include_router(sessions.router, prefix="/api/sessions", tags=["sessions"])
+    app.include_router(agents.router, prefix="/api/agents", tags=["agents"])
+
+    # WebSocket endpoints (events + terminal)
+    from code_puppy.api.websocket import setup_websocket
+
+    setup_websocket(app)
+
+    # Templates directory
+    templates_dir = Path(__file__).parent / "templates"
+
+    @app.get("/")
+    async def root():
+        """Landing page with links to terminal and docs."""
+        return HTMLResponse(
+            content="""
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Code Puppy 🐶</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+</head>
+<body class="bg-gray-900 text-white min-h-screen flex items-center justify-center">
+    <div class="text-center">
+        <h1 class="text-6xl mb-4">🐶</h1>
+        <h2 class="text-3xl font-bold mb-8">Code Puppy</h2>
+        <div class="space-x-4">
+            <a href="/terminal" class="px-6 py-3 bg-blue-600 hover:bg-blue-700 rounded-lg text-lg font-semibold">
+                Open Terminal
+            </a>
+            <a href="/docs" class="px-6 py-3 bg-gray-700 hover:bg-gray-600 rounded-lg text-lg">
+                API Docs
+            </a>
+        </div>
+        <p class="mt-8 text-gray-400">
+            WebSocket: ws://localhost:8765/ws/terminal
+        </p>
+    </div>
+</body>
+</html>
+        """
+        )
+
+    @app.get("/terminal")
+    async def terminal_page():
+        """Serve the interactive terminal page."""
+        html_file = templates_dir / "terminal.html"
+        if html_file.exists():
+            return FileResponse(html_file, media_type="text/html")
+        return HTMLResponse(
+            content="<h1>Terminal template not found</h1>",
+            status_code=404,
+        )
+
+    @app.get("/health")
+    async def health():
+        return {"status": "healthy"}
+
+    return app

code_puppy/api/main.py

@@ -0,0 +1,21 @@
+"""Entry point for running the FastAPI server."""
+
+import uvicorn
+
+from code_puppy.api.app import create_app
+
+app = create_app()
+
+
+def main(host: str = "127.0.0.1", port: int = 8765) -> None:
+    """Run the FastAPI server.
+
+    Args:
+        host: The host address to bind to. Defaults to localhost.
+        port: The port number to listen on. Defaults to 8765.
+    """
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()