code-puppy 0.0.169__py3-none-any.whl → 0.0.366__py3-none-any.whl

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,169 @@
+"""FastAPI application factory for Code Puppy API."""
+
+import asyncio
+import logging
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import AsyncGenerator
+
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
+from starlette.middleware.base import BaseHTTPMiddleware
+
+logger = logging.getLogger(__name__)
+
+# Default request timeout (seconds) - fail fast!
+REQUEST_TIMEOUT = 30.0
+
+
+class TimeoutMiddleware(BaseHTTPMiddleware):
+    """Middleware to enforce request timeouts and prevent hanging requests."""
+
+    def __init__(self, app, timeout: float = REQUEST_TIMEOUT):
+        super().__init__(app)
+        self.timeout = timeout
+
+    async def dispatch(self, request: Request, call_next):
+        # Skip timeout for WebSocket upgrades and streaming endpoints
+        if request.headers.get(
+            "upgrade", ""
+        ).lower() == "websocket" or request.url.path.startswith("/ws/"):
+            return await call_next(request)
+
+        try:
+            return await asyncio.wait_for(
+                call_next(request),
+                timeout=self.timeout,
+            )
+        except asyncio.TimeoutError:
+            return JSONResponse(
+                status_code=504,
+                content={
+                    "detail": f"Request timed out after {self.timeout}s",
+                    "error": "timeout",
+                },
+            )
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """Lifespan context manager for startup and shutdown events.
+
+    Handles graceful cleanup of resources when the server shuts down.
+    """
+    # Startup: nothing special needed yet, but this is where you'd do it
+    logger.info("🐶 Code Puppy API starting up...")
+    yield
+    # Shutdown: clean up all the things!
+    logger.info("🐶 Code Puppy API shutting down, cleaning up...")
+
+    # 1. Close all PTY sessions
+    try:
+        from code_puppy.api.pty_manager import get_pty_manager
+
+        pty_manager = get_pty_manager()
+        await pty_manager.close_all()
+        logger.info("✓ All PTY sessions closed")
+    except Exception as e:
+        logger.error(f"Error closing PTY sessions: {e}")
+
+    # 2. Remove PID file so /api status knows we're gone
+    try:
+        from code_puppy.config import STATE_DIR
+
+        pid_file = Path(STATE_DIR) / "api_server.pid"
+        if pid_file.exists():
+            pid_file.unlink()
+            logger.info("✓ PID file removed")
+    except Exception as e:
+        logger.error(f"Error removing PID file: {e}")
+
+
+def create_app() -> FastAPI:
+    """Create and configure the FastAPI application."""
+    app = FastAPI(
+        lifespan=lifespan,
+        title="Code Puppy API",
+        description="REST API and Interactive Terminal for Code Puppy",
+        version="1.0.0",
+        docs_url="/docs",
+        redoc_url="/redoc",
+    )
+
+    # Timeout middleware - added first so it wraps everything
+    app.add_middleware(TimeoutMiddleware, timeout=REQUEST_TIMEOUT)
+
+    # 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()