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

code_puppy/api/websocket.py

@@ -0,0 +1,154 @@
+"""WebSocket endpoints for Code Puppy API.
+
+Provides real-time communication channels:
+- /ws/events - Server-sent events stream
+- /ws/terminal - Interactive PTY terminal sessions
+- /ws/health - Simple health check endpoint
+"""
+
+import asyncio
+import base64
+import logging
+import uuid
+
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+
+logger = logging.getLogger(__name__)
+
+
+def setup_websocket(app: FastAPI) -> None:
+    """Setup WebSocket endpoints for the application."""
+
+    @app.websocket("/ws/events")
+    async def websocket_events(websocket: WebSocket) -> None:
+        """Stream real-time events to connected clients."""
+        await websocket.accept()
+        logger.info("Events WebSocket client connected")
+
+        from code_puppy.plugins.frontend_emitter.emitter import (
+            get_recent_events,
+            subscribe,
+            unsubscribe,
+        )
+
+        event_queue = subscribe()
+
+        try:
+            recent_events = get_recent_events()
+            for event in recent_events:
+                await websocket.send_json(event)
+
+            while True:
+                try:
+                    event = await asyncio.wait_for(event_queue.get(), timeout=30.0)
+                    await websocket.send_json(event)
+                except asyncio.TimeoutError:
+                    try:
+                        await websocket.send_json({"type": "ping"})
+                    except Exception:
+                        break
+        except WebSocketDisconnect:
+            logger.info("Events WebSocket client disconnected")
+        except Exception as e:
+            logger.error(f"Events WebSocket error: {e}")
+        finally:
+            unsubscribe(event_queue)
+
+    @app.websocket("/ws/terminal")
+    async def websocket_terminal(websocket: WebSocket) -> None:
+        """Interactive terminal WebSocket endpoint."""
+        await websocket.accept()
+        logger.info("Terminal WebSocket client connected")
+
+        from code_puppy.api.pty_manager import get_pty_manager
+
+        manager = get_pty_manager()
+        session_id = str(uuid.uuid4())[:8]
+        session = None
+
+        # Get the current event loop for thread-safe scheduling
+        loop = asyncio.get_running_loop()
+
+        # Queue to receive PTY output in a thread-safe way
+        output_queue: asyncio.Queue[bytes] = asyncio.Queue()
+
+        # Output callback - called from thread pool, puts data in queue
+        def on_output(data: bytes) -> None:
+            try:
+                loop.call_soon_threadsafe(output_queue.put_nowait, data)
+            except Exception as e:
+                logger.error(f"on_output error: {e}")
+
+        async def output_sender() -> None:
+            """Coroutine that sends queued output to WebSocket."""
+            try:
+                while True:
+                    data = await output_queue.get()
+                    await websocket.send_json(
+                        {
+                            "type": "output",
+                            "data": base64.b64encode(data).decode("ascii"),
+                        }
+                    )
+            except asyncio.CancelledError:
+                pass
+            except Exception as e:
+                logger.error(f"output_sender error: {e}")
+
+        sender_task = None
+
+        try:
+            # Create PTY session
+            session = await manager.create_session(
+                session_id=session_id,
+                on_output=on_output,
+            )
+
+            # Send session info
+            await websocket.send_json({"type": "session", "id": session_id})
+
+            # Start output sender task
+            sender_task = asyncio.create_task(output_sender())
+
+            # Handle incoming messages
+            while True:
+                try:
+                    msg = await websocket.receive_json()
+
+                    if msg.get("type") == "input":
+                        data = msg.get("data", "")
+                        if isinstance(data, str):
+                            data = data.encode("utf-8")
+                        await manager.write(session_id, data)
+                    elif msg.get("type") == "resize":
+                        cols = msg.get("cols", 80)
+                        rows = msg.get("rows", 24)
+                        await manager.resize(session_id, cols, rows)
+                except WebSocketDisconnect:
+                    break
+                except Exception as e:
+                    logger.error(f"Terminal WebSocket error: {e}")
+                    break
+        except Exception as e:
+            logger.error(f"Terminal session error: {e}")
+        finally:
+            if sender_task:
+                sender_task.cancel()
+                try:
+                    await sender_task
+                except asyncio.CancelledError:
+                    pass
+            if session:
+                await manager.close_session(session_id)
+            logger.info("Terminal WebSocket disconnected")
+
+    @app.websocket("/ws/health")
+    async def websocket_health(websocket: WebSocket) -> None:
+        """Simple WebSocket health check - echoes messages back."""
+        await websocket.accept()
+        try:
+            while True:
+                data = await websocket.receive_text()
+                await websocket.send_text(f"echo: {data}")
+        except WebSocketDisconnect:
+            pass

code_puppy/callbacks.py

@@ -15,6 +15,12 @@ PhaseType = Literal[
     "load_model_config",
     "load_prompt",
     "agent_reload",
+    "custom_command",
+    "custom_command_help",
+    "file_permission",
+    "pre_tool_call",
+    "post_tool_call",
+    "stream_event",
 ]
 CallbackFunc = Callable[..., Any]
 
@@ -30,6 +36,12 @@ _callbacks: Dict[PhaseType, List[CallbackFunc]] = {
     "load_model_config": [],
     "load_prompt": [],
     "agent_reload": [],
+    "custom_command": [],
+    "custom_command_help": [],
+    "file_permission": [],
+    "pre_tool_call": [],
+    "post_tool_call": [],
+    "stream_event": [],
 }
 
 logger = logging.getLogger(__name__)
@@ -44,6 +56,14 @@ def register_callback(phase: PhaseType, func: CallbackFunc) -> None:
     if not callable(func):
         raise TypeError(f"Callback must be callable, got {type(func)}")
 
+    # Prevent duplicate registration of the same callback function
+    # This can happen if plugins are accidentally loaded multiple times
+    if func in _callbacks[phase]:
+        logger.debug(
+            f"Callback {func.__name__} already registered for phase '{phase}', skipping"
+        )
+        return
+
     _callbacks[phase].append(func)
     logger.debug(f"Registered async callback {func.__name__} for phase '{phase}'")
 
@@ -93,11 +113,27 @@ def _trigger_callbacks_sync(phase: PhaseType, *args, **kwargs) -> List[Any]:
     for callback in callbacks:
         try:
             result = callback(*args, **kwargs)
+            # Handle async callbacks - if we get a coroutine, run it
+            if asyncio.iscoroutine(result):
+                # Try to get the running event loop
+                try:
+                    asyncio.get_running_loop()
+                    # We're in an async context already - this shouldn't happen for sync triggers
+                    # but if it does, we can't use run_until_complete
+                    logger.warning(
+                        f"Async callback {callback.__name__} called from async context in sync trigger"
+                    )
+                    results.append(None)
+                    continue
+                except RuntimeError:
+                    # No running loop - we're in a sync/worker thread context
+                    # Use asyncio.run() which is safe here since we're in an isolated thread
+                    result = asyncio.run(result)
             results.append(result)
-            logger.debug(f"Successfully executed async callback {callback.__name__}")
+            logger.debug(f"Successfully executed callback {callback.__name__}")
         except Exception as e:
             logger.error(
-                f"Async callback {callback.__name__} failed in phase '{phase}': {e}\n"
+                f"Callback {callback.__name__} failed in phase '{phase}': {e}\n"
                 f"{traceback.format_exc()}"
             )
             results.append(None)
@@ -164,8 +200,8 @@ def on_delete_file(*args, **kwargs) -> Any:
     return _trigger_callbacks_sync("delete_file", *args, **kwargs)
 
 
-def on_run_shell_command(*args, **kwargs) -> Any:
-    return _trigger_callbacks_sync("run_shell_command", *args, **kwargs)
+async def on_run_shell_command(*args, **kwargs) -> Any:
+    return await _trigger_callbacks("run_shell_command", *args, **kwargs)
 
 
 def on_agent_reload(*args, **kwargs) -> Any:
@@ -174,3 +210,137 @@ def on_agent_reload(*args, **kwargs) -> Any:
 
 def on_load_prompt():
     return _trigger_callbacks_sync("load_prompt")
+
+
+def on_custom_command_help() -> List[Any]:
+    """Collect custom command help entries from plugins.
+
+    Each callback should return a list of tuples [(name, description), ...]
+    or a single tuple, or None. We'll flatten and sanitize results.
+    """
+    return _trigger_callbacks_sync("custom_command_help")
+
+
+def on_custom_command(command: str, name: str) -> List[Any]:
+    """Trigger custom command callbacks.
+
+    This allows plugins to register handlers for slash commands
+    that are not built into the core command handler.
+
+    Args:
+        command: The full command string (e.g., "/foo bar baz").
+        name: The primary command name without the leading slash (e.g., "foo").
+
+    Returns:
+        Implementations may return:
+        - True if the command was handled (and no further action is needed)
+        - A string to be processed as user input by the caller
+        - None to indicate not handled
+    """
+    return _trigger_callbacks_sync("custom_command", command, name)
+
+
+def on_file_permission(
+    context: Any,
+    file_path: str,
+    operation: str,
+    preview: str | None = None,
+    message_group: str | None = None,
+    operation_data: Any = None,
+) -> List[Any]:
+    """Trigger file permission callbacks.
+
+    This allows plugins to register handlers for file permission checks
+    before file operations are performed.
+
+    Args:
+        context: The operation context
+        file_path: Path to the file being operated on
+        operation: Description of the operation
+        preview: Optional preview of changes (deprecated - use operation_data instead)
+        message_group: Optional message group
+        operation_data: Operation-specific data for preview generation (recommended)
+
+    Returns:
+        List of boolean results from permission handlers.
+        Returns True if permission should be granted, False if denied.
+    """
+    # For backward compatibility, if operation_data is provided, prefer it over preview
+    if operation_data is not None:
+        preview = None
+    return _trigger_callbacks_sync(
+        "file_permission",
+        context,
+        file_path,
+        operation,
+        preview,
+        message_group,
+        operation_data,
+    )
+
+
+async def on_pre_tool_call(
+    tool_name: str, tool_args: dict, context: Any = None
+) -> List[Any]:
+    """Trigger callbacks before a tool is called.
+
+    This allows plugins to inspect, modify, or log tool calls before
+    they are executed.
+
+    Args:
+        tool_name: Name of the tool being called
+        tool_args: Arguments being passed to the tool
+        context: Optional context data for the tool call
+
+    Returns:
+        List of results from registered callbacks.
+    """
+    return await _trigger_callbacks("pre_tool_call", tool_name, tool_args, context)
+
+
+async def on_post_tool_call(
+    tool_name: str,
+    tool_args: dict,
+    result: Any,
+    duration_ms: float,
+    context: Any = None,
+) -> List[Any]:
+    """Trigger callbacks after a tool completes.
+
+    This allows plugins to inspect tool results, log execution times,
+    or perform post-processing.
+
+    Args:
+        tool_name: Name of the tool that was called
+        tool_args: Arguments that were passed to the tool
+        result: The result returned by the tool
+        duration_ms: Execution time in milliseconds
+        context: Optional context data for the tool call
+
+    Returns:
+        List of results from registered callbacks.
+    """
+    return await _trigger_callbacks(
+        "post_tool_call", tool_name, tool_args, result, duration_ms, context
+    )
+
+
+async def on_stream_event(
+    event_type: str, event_data: Any, agent_session_id: str | None = None
+) -> List[Any]:
+    """Trigger callbacks for streaming events.
+
+    This allows plugins to react to streaming events in real-time,
+    such as tokens being generated, tool calls starting, etc.
+
+    Args:
+        event_type: Type of the streaming event
+        event_data: Data associated with the event
+        agent_session_id: Optional session ID of the agent emitting the event
+
+    Returns:
+        List of results from registered callbacks.
+    """
+    return await _trigger_callbacks(
+        "stream_event", event_type, event_data, agent_session_id
+    )

code_puppy/chatgpt_codex_client.py

@@ -0,0 +1,283 @@
+"""HTTP client interceptor for ChatGPT Codex API.
+
+ChatGPTCodexAsyncClient: httpx client that injects required fields into
+request bodies for the ChatGPT Codex API and handles stream-to-non-stream
+conversion.
+
+The Codex API requires:
+- "store": false - Disables conversation storage
+- "stream": true - Streaming is mandatory
+
+Removes unsupported parameters:
+- "max_output_tokens" - Not supported by Codex API
+- "max_tokens" - Not supported by Codex API
+- "verbosity" - Not supported by Codex API
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+
+def _is_reasoning_model(model_name: str) -> bool:
+    """Check if a model supports reasoning parameters."""
+    reasoning_models = [
+        "gpt-5",  # All GPT-5 variants
+        "o1",  # o1 series
+        "o3",  # o3 series
+        "o4",  # o4 series
+    ]
+    model_lower = model_name.lower()
+    return any(model_lower.startswith(prefix) for prefix in reasoning_models)
+
+
+class ChatGPTCodexAsyncClient(httpx.AsyncClient):
+    """Async HTTP client that handles ChatGPT Codex API requirements.
+
+    This client:
+    1. Injects required fields (store=false, stream=true)
+    2. Strips unsupported parameters
+    3. Converts streaming responses to non-streaming format
+    """
+
+    async def send(
+        self, request: httpx.Request, *args: Any, **kwargs: Any
+    ) -> httpx.Response:
+        """Intercept requests and inject required Codex fields."""
+        force_stream_conversion = False
+
+        try:
+            # Only modify POST requests to the Codex API
+            if request.method == "POST":
+                body_bytes = self._extract_body_bytes(request)
+                if body_bytes:
+                    updated, force_stream_conversion = self._inject_codex_fields(
+                        body_bytes
+                    )
+                    if updated is not None:
+                        try:
+                            rebuilt = self.build_request(
+                                method=request.method,
+                                url=request.url,
+                                headers=request.headers,
+                                content=updated,
+                            )
+
+                            # Copy core internals so httpx uses the modified body/stream
+                            if hasattr(rebuilt, "_content"):
+                                setattr(request, "_content", rebuilt._content)
+                            if hasattr(rebuilt, "stream"):
+                                request.stream = rebuilt.stream
+                            if hasattr(rebuilt, "extensions"):
+                                request.extensions = rebuilt.extensions
+
+                            # Ensure Content-Length matches the new body
+                            request.headers["Content-Length"] = str(len(updated))
+
+                        except Exception:
+                            pass
+        except Exception:
+            pass
+
+        # Make the actual request
+        response = await super().send(request, *args, **kwargs)
+
+        # If we forced streaming, convert the SSE stream to a regular response
+        if force_stream_conversion and response.status_code == 200:
+            try:
+                response = await self._convert_stream_to_response(response)
+            except Exception as e:
+                logger.warning(f"Failed to convert stream response: {e}")
+
+        return response
+
+    @staticmethod
+    def _extract_body_bytes(request: httpx.Request) -> bytes | None:
+        """Extract the request body as bytes."""
+        try:
+            content = request.content
+            if content:
+                return content
+        except Exception:
+            pass
+
+        try:
+            content = getattr(request, "_content", None)
+            if content:
+                return content
+        except Exception:
+            pass
+
+        return None
+
+    @staticmethod
+    def _inject_codex_fields(body: bytes) -> tuple[bytes | None, bool]:
+        """Inject required Codex fields and remove unsupported ones.
+
+        Returns:
+            Tuple of (modified body bytes or None, whether stream was forced)
+        """
+        try:
+            data = json.loads(body.decode("utf-8"))
+        except Exception:
+            return None, False
+
+        if not isinstance(data, dict):
+            return None, False
+
+        modified = False
+        forced_stream = False
+
+        # CRITICAL: ChatGPT Codex backend requires store=false
+        if "store" not in data or data.get("store") is not False:
+            data["store"] = False
+            modified = True
+
+        # CRITICAL: ChatGPT Codex backend requires stream=true
+        # If stream is already true (e.g., pydantic-ai with event_stream_handler),
+        # don't force conversion - let streaming events flow through naturally
+        if data.get("stream") is not True:
+            data["stream"] = True
+            forced_stream = True  # Only convert if WE forced streaming
+            modified = True
+
+        # Add reasoning settings for reasoning models (gpt-5.2, o-series, etc.)
+        model = data.get("model", "")
+        if "reasoning" not in data and _is_reasoning_model(model):
+            data["reasoning"] = {
+                "effort": "medium",
+                "summary": "auto",
+            }
+            modified = True
+
+        # Remove unsupported parameters
+        # Note: verbosity should be under "text" object, not top-level
+        unsupported_params = ["max_output_tokens", "max_tokens", "verbosity"]
+        for param in unsupported_params:
+            if param in data:
+                del data[param]
+                modified = True
+
+        if not modified:
+            return None, False
+
+        return json.dumps(data).encode("utf-8"), forced_stream
+
+    async def _convert_stream_to_response(
+        self, response: httpx.Response
+    ) -> httpx.Response:
+        """Convert an SSE streaming response to a complete response.
+
+        Consumes the SSE stream and reconstructs the final response object.
+        """
+        logger.debug("Converting SSE stream to non-streaming response")
+        final_response_data = None
+        collected_text = []
+        collected_tool_calls = []
+
+        # Read the entire stream
+        async for line in response.aiter_lines():
+            if not line or not line.startswith("data:"):
+                continue
+
+            data_str = line[5:].strip()  # Remove "data:" prefix
+            if data_str == "[DONE]":
+                break
+
+            try:
+                event = json.loads(data_str)
+                event_type = event.get("type", "")
+
+                if event_type == "response.output_text.delta":
+                    # Collect text deltas
+                    delta = event.get("delta", "")
+                    if delta:
+                        collected_text.append(delta)
+
+                elif event_type == "response.completed":
+                    # This contains the final response object
+                    final_response_data = event.get("response", {})
+
+                elif event_type == "response.function_call_arguments.done":
+                    # Collect tool calls
+                    tool_call = {
+                        "name": event.get("name", ""),
+                        "arguments": event.get("arguments", ""),
+                        "call_id": event.get("call_id", ""),
+                    }
+                    collected_tool_calls.append(tool_call)
+
+            except json.JSONDecodeError:
+                continue
+
+        logger.debug(
+            f"Collected {len(collected_text)} text chunks, {len(collected_tool_calls)} tool calls"
+        )
+        if final_response_data:
+            logger.debug(
+                f"Got final response data with keys: {list(final_response_data.keys())}"
+            )
+
+        # Build the final response body
+        if final_response_data:
+            response_body = final_response_data
+        else:
+            # Fallback: construct a minimal response from collected data
+            response_body = {
+                "id": "reconstructed",
+                "object": "response",
+                "output": [],
+            }
+
+            if collected_text:
+                response_body["output"].append(
+                    {
+                        "type": "message",
+                        "role": "assistant",
+                        "content": [
+                            {"type": "output_text", "text": "".join(collected_text)}
+                        ],
+                    }
+                )
+
+            for tool_call in collected_tool_calls:
+                response_body["output"].append(
+                    {
+                        "type": "function_call",
+                        "name": tool_call["name"],
+                        "arguments": tool_call["arguments"],
+                        "call_id": tool_call["call_id"],
+                    }
+                )
+
+        # Create a new response with the complete body
+        body_bytes = json.dumps(response_body).encode("utf-8")
+        logger.debug(f"Reconstructed response body: {len(body_bytes)} bytes")
+
+        new_response = httpx.Response(
+            status_code=response.status_code,
+            headers=response.headers,
+            content=body_bytes,
+            request=response.request,
+        )
+        return new_response
+
+
+def create_codex_async_client(
+    headers: dict[str, str] | None = None,
+    verify: str | bool = True,
+    **kwargs: Any,
+) -> ChatGPTCodexAsyncClient:
+    """Create a ChatGPT Codex async client with proper configuration."""
+    return ChatGPTCodexAsyncClient(
+        headers=headers,
+        verify=verify,
+        timeout=httpx.Timeout(300.0, connect=30.0),
+        **kwargs,
+    )