minion-code 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

minion_code/web/api/chat.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Chat API endpoint with SSE streaming.
+
+Handles chat messages and returns streaming responses via Server-Sent Events.
+"""
+
+import asyncio
+import json
+import logging
+from typing import Optional, AsyncGenerator
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel, Field
+
+from ..services.session_manager import session_manager, HistoryMode
+from ..adapters.web_adapter import TaskState, SSEEvent
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/chat", tags=["chat"])
+
+
+class ChatRequest(BaseModel):
+    """Request body for chat endpoint."""
+
+    message: str = Field(..., description="User message content")
+    history_mode: Optional[HistoryMode] = Field(
+        default=None, description="Override session's history mode for this request"
+    )
+
+
+def format_sse_event(event: SSEEvent) -> str:
+    """Format event as SSE string."""
+    data = json.dumps(event.to_dict(), ensure_ascii=False)
+    return f"data: {data}\n\n"
+
+
+def format_sse_done() -> str:
+    """Format done event."""
+    return "data: [DONE]\n\n"
+
+
+async def process_chat_stream(
+    session_id: str, message: str, history_mode: Optional[HistoryMode] = None
+) -> AsyncGenerator[str, None]:
+    """
+    Process chat message and yield SSE events.
+
+    This is the core streaming logic:
+    1. Get or create session
+    2. Create task ID and update adapter
+    3. Get agent (based on history mode)
+    4. Run agent and forward events
+    5. Save messages to storage
+    """
+    # Get session
+    session = await session_manager.get_session(session_id)
+    if not session:
+        yield format_sse_event(
+            SSEEvent(
+                type="error",
+                data={"message": "Session not found", "code": "SESSION_NOT_FOUND"},
+            )
+        )
+        yield format_sse_done()
+        return
+
+    # Use request history_mode or session default
+    effective_history_mode = history_mode or session.history_mode
+
+    # Generate task ID
+    task_id = session.generate_task_id()
+    session.current_task_id = task_id
+    session.adapter.set_task_id(task_id)
+
+    # Reset abort event
+    session.abort_event.clear()
+
+    try:
+        # Emit task started
+        await session.adapter.emit_task_status(TaskState.SUBMITTED)
+        yield format_sse_event(
+            SSEEvent(
+                type="task_status",
+                data={"state": TaskState.SUBMITTED.value, "task_id": task_id},
+                task_id=task_id,
+            )
+        )
+
+        # Get or create agent
+        agent = await session_manager.get_or_create_agent(session)
+
+        # Emit working status
+        await session.adapter.emit_task_status(TaskState.WORKING)
+        yield format_sse_event(
+            SSEEvent(
+                type="task_status",
+                data={"state": TaskState.WORKING.value, "task_id": task_id},
+                task_id=task_id,
+            )
+        )
+
+        # Save user message
+        session_manager.save_message(session, "user", message)
+
+        # Run agent with streaming
+        full_response = ""
+
+        # Create concurrent tasks for agent execution and event forwarding
+        async def run_agent():
+            nonlocal full_response
+            async for chunk in agent.run_async(message, stream=True):
+                # Check for abort
+                if session.abort_event.is_set():
+                    break
+
+                chunk_type = getattr(chunk, "chunk_type", "text")
+                chunk_content = getattr(chunk, "content", str(chunk))
+                chunk_metadata = getattr(chunk, "metadata", {})
+
+                if chunk_type == "step_start":
+                    await session.adapter._emit_event(
+                        "step_start", {"content": chunk_content}
+                    )
+                elif chunk_type == "thinking":
+                    await session.adapter.emit_thinking(chunk_content)
+                elif chunk_type == "code_start":
+                    await session.adapter._emit_event(
+                        "code_start",
+                        {
+                            "code": chunk_content,
+                            "language": chunk_metadata.get("language", ""),
+                        },
+                    )
+                elif chunk_type == "code_result":
+                    await session.adapter.emit_tool_result(
+                        success=chunk_metadata.get("success", True),
+                        output=chunk_content,
+                    )
+                elif chunk_type == "tool_call":
+                    await session.adapter.emit_tool_call(
+                        name=chunk_metadata.get("tool_name", ""),
+                        args=chunk_metadata.get("args", {}),
+                    )
+                elif chunk_type in ("final_answer", "agent_response", "completion"):
+                    final_content = (
+                        getattr(chunk, "answer", chunk_content) or chunk_content
+                    )
+                    full_response = str(final_content)
+                    await session.adapter.emit_content(full_response)
+                else:
+                    # Default: treat as content
+                    if chunk_content:
+                        await session.adapter.emit_content(chunk_content)
+
+        # Start agent execution in background
+        agent_task = asyncio.create_task(run_agent())
+
+        # Forward events from adapter queue to SSE
+        try:
+            while True:
+                try:
+                    # Try to get event with timeout
+                    event = await asyncio.wait_for(
+                        session.adapter.event_queue.get(), timeout=0.1
+                    )
+                    yield format_sse_event(event)
+                except asyncio.TimeoutError:
+                    pass
+
+                # Check if agent is done
+                if agent_task.done():
+                    # Drain remaining events
+                    while not session.adapter.event_queue.empty():
+                        event = await session.adapter.event_queue.get()
+                        yield format_sse_event(event)
+
+                    # Check for exception
+                    if agent_task.exception():
+                        raise agent_task.exception()
+
+                    break
+
+                # Check for abort
+                if session.abort_event.is_set():
+                    agent_task.cancel()
+                    yield format_sse_event(
+                        SSEEvent(
+                            type="task_status",
+                            data={
+                                "state": TaskState.CANCELLED.value,
+                                "task_id": task_id,
+                            },
+                            task_id=task_id,
+                        )
+                    )
+                    break
+
+        except Exception as e:
+            logger.error(f"Error in event forwarding: {e}")
+            raise
+
+        # Save assistant response
+        if full_response:
+            session_manager.save_message(session, "assistant", full_response)
+
+        # Emit completed status
+        await session.adapter.emit_task_status(TaskState.COMPLETED)
+        yield format_sse_event(
+            SSEEvent(
+                type="task_status",
+                data={"state": TaskState.COMPLETED.value, "task_id": task_id},
+                task_id=task_id,
+            )
+        )
+
+    except asyncio.CancelledError:
+        yield format_sse_event(
+            SSEEvent(
+                type="task_status",
+                data={"state": TaskState.CANCELLED.value, "task_id": task_id},
+                task_id=task_id,
+            )
+        )
+    except Exception as e:
+        logger.exception(f"Error processing chat: {e}")
+        await session.adapter.emit_error(str(e))
+        yield format_sse_event(
+            SSEEvent(type="error", data={"message": str(e)}, task_id=task_id)
+        )
+        await session.adapter.emit_task_status(TaskState.FAILED)
+        yield format_sse_event(
+            SSEEvent(
+                type="task_status",
+                data={"state": TaskState.FAILED.value, "task_id": task_id},
+                task_id=task_id,
+            )
+        )
+    finally:
+        session.current_task_id = None
+        yield format_sse_done()
+
+
+@router.post("/{session_id}")
+async def chat(session_id: str, request: ChatRequest):
+    """
+    Send a chat message and receive streaming response.
+
+    Returns a Server-Sent Events stream with the following event types:
+    - task_status: Task state changes (submitted, working, input_required, completed, failed)
+    - content: Streaming text content
+    - thinking: LLM reasoning content
+    - tool_call: Tool invocation
+    - tool_result: Tool execution result
+    - input_required: Request for user input (permission, text, choice)
+    - error: Error message
+    - done: Stream end marker ([DONE])
+
+    For input_required events, respond via POST /api/tasks/{task_id}/input
+    """
+    # Validate session exists
+    session = await session_manager.get_session(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    return StreamingResponse(
+        process_chat_stream(session_id, request.message, request.history_mode),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",  # Disable nginx buffering
+        },
+    )

minion_code/web/api/interactions.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Interactions API endpoint.
+
+Handles user responses to input_required events (permission, text input, choice).
+"""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+from typing import Union, Optional, Any
+
+from ..services.session_manager import session_manager
+
+router = APIRouter(prefix="/api/tasks", tags=["interactions"])
+
+
+class InteractionResponse(BaseModel):
+    """Request body for responding to an interaction."""
+
+    interaction_id: str = Field(
+        ..., description="Interaction ID from input_required event"
+    )
+    response: Any = Field(
+        ...,
+        description="User's response: bool for permission, int for choice, str for text",
+    )
+
+
+class InteractionResult(BaseModel):
+    """Response after processing interaction."""
+
+    status: str
+    interaction_id: str
+    task_id: Optional[str] = None
+
+
+@router.post("/{task_id}/input", response_model=InteractionResult)
+async def respond_to_interaction(task_id: str, body: InteractionResponse):
+    """
+    Respond to an input_required event.
+
+    This endpoint is called when the user responds to a permission request,
+    makes a choice, or provides text input.
+
+    The response type depends on the interaction kind:
+    - permission: bool (true = allow, false = deny)
+    - choice: int (selected index, -1 = cancelled)
+    - text: str or null (null = cancelled)
+
+    Example:
+        POST /api/tasks/task_123/input
+        {
+            "interaction_id": "int_456",
+            "response": true
+        }
+    """
+    # Find session containing this interaction
+    session = session_manager.find_session_by_interaction(body.interaction_id)
+    if not session:
+        raise HTTPException(
+            status_code=404, detail=f"Interaction {body.interaction_id} not found"
+        )
+
+    # Verify task_id matches (optional validation)
+    if session.current_task_id and session.current_task_id != task_id:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Task ID mismatch: expected {session.current_task_id}, got {task_id}",
+        )
+
+    # Resolve the interaction
+    resolved = session.adapter.resolve_interaction(body.interaction_id, body.response)
+    if not resolved:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Interaction {body.interaction_id} already resolved or not found",
+        )
+
+    return InteractionResult(
+        status="ok", interaction_id=body.interaction_id, task_id=task_id
+    )
+
+
+@router.post("/{task_id}/cancel")
+async def cancel_interaction(task_id: str, interaction_id: str):
+    """
+    Cancel a pending interaction.
+
+    Sets appropriate default value based on interaction type:
+    - permission: false (denied)
+    - choice: -1 (cancelled)
+    - text: null (cancelled)
+    """
+    session = session_manager.find_session_by_interaction(interaction_id)
+    if not session:
+        raise HTTPException(
+            status_code=404, detail=f"Interaction {interaction_id} not found"
+        )
+
+    cancelled = session.adapter.cancel_interaction(interaction_id)
+    if not cancelled:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Interaction {interaction_id} already resolved or not found",
+        )
+
+    return {"status": "cancelled", "interaction_id": interaction_id, "task_id": task_id}
+
+
+# Alternative endpoint path for convenience
+@router.post("/input/{interaction_id}")
+async def respond_to_interaction_by_id(interaction_id: str, response: Any):
+    """
+    Alternative endpoint to respond by interaction ID only.
+
+    Useful when task_id is not readily available.
+    """
+    session = session_manager.find_session_by_interaction(interaction_id)
+    if not session:
+        raise HTTPException(
+            status_code=404, detail=f"Interaction {interaction_id} not found"
+        )
+
+    resolved = session.adapter.resolve_interaction(interaction_id, response)
+    if not resolved:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Interaction {interaction_id} already resolved or not found",
+        )
+
+    return {
+        "status": "ok",
+        "interaction_id": interaction_id,
+        "task_id": session.current_task_id,
+    }

minion_code/web/api/sessions.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Sessions API endpoints.
+
+Handles session creation, retrieval, and management.
+"""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+from typing import Optional, List, Dict, Any
+
+from ..services.session_manager import session_manager, HistoryMode
+
+router = APIRouter(prefix="/api/sessions", tags=["sessions"])
+
+
+class CreateSessionRequest(BaseModel):
+    """Request body for creating a session."""
+
+    project_path: str = Field(
+        default=".", description="Working directory for the session"
+    )
+    history_mode: Optional[HistoryMode] = Field(
+        default=None,
+        description="History mode: 'full' (stateless) or 'incremental' (stateful)",
+    )
+
+
+class SessionResponse(BaseModel):
+    """Response for session operations."""
+
+    session_id: str
+    project_path: str
+    history_mode: str
+    created_at: float
+    message_count: int = 0
+
+
+class SessionListResponse(BaseModel):
+    """Response for listing sessions."""
+
+    sessions: List[Dict[str, Any]]
+
+
+@router.post("", response_model=SessionResponse)
+async def create_session(request: CreateSessionRequest):
+    """
+    Create a new session.
+
+    Returns a session ID that can be used for subsequent chat requests.
+    """
+    try:
+        session = await session_manager.create_session(
+            project_path=request.project_path, history_mode=request.history_mode
+        )
+
+        return SessionResponse(
+            session_id=session.session_id,
+            project_path=session.project_path,
+            history_mode=session.history_mode,
+            created_at=session.created_at,
+            message_count=0,
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("", response_model=SessionListResponse)
+async def list_sessions():
+    """List all active sessions."""
+    sessions = session_manager.list_sessions()
+    return SessionListResponse(sessions=sessions)
+
+
+@router.get("/{session_id}", response_model=SessionResponse)
+async def get_session(session_id: str):
+    """
+    Get session details.
+
+    Returns session info including message history.
+    """
+    session = await session_manager.get_session(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    messages = session_manager.get_messages(session)
+
+    return SessionResponse(
+        session_id=session.session_id,
+        project_path=session.project_path,
+        history_mode=session.history_mode,
+        created_at=session.created_at,
+        message_count=len(messages),
+    )
+
+
+@router.get("/{session_id}/messages")
+async def get_session_messages(session_id: str):
+    """
+    Get message history for a session.
+
+    Returns all messages in the conversation.
+    """
+    session = await session_manager.get_session(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    messages = session_manager.get_messages(session)
+
+    return {"session_id": session_id, "messages": messages}
+
+
+@router.delete("/{session_id}")
+async def delete_session(session_id: str):
+    """Delete a session."""
+    deleted = await session_manager.delete_session(session_id)
+    if not deleted:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    return {"status": "ok", "session_id": session_id}
+
+
+@router.post("/{session_id}/abort")
+async def abort_session_task(session_id: str):
+    """
+    Abort the current task in a session.
+
+    Sends abort signal to stop ongoing processing.
+    """
+    aborted = await session_manager.abort_task(session_id)
+    if not aborted:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    return {"status": "ok", "session_id": session_id}

minion_code/web/server.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+FastAPI Web Server for minion-code.
+
+Provides HTTP/SSE API for cross-process frontend communication.
+"""
+
+import logging
+from typing import Optional
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from .api import chat_router, sessions_router, interactions_router
+
+logger = logging.getLogger(__name__)
+
+
+def create_app(
+    title: str = "Minion Code API",
+    version: str = "1.0.0",
+    cors_origins: Optional[list] = None,
+) -> FastAPI:
+    """
+    Create and configure FastAPI application.
+
+    Args:
+        title: API title
+        version: API version
+        cors_origins: Allowed CORS origins (default: localhost:3000, localhost:5173)
+
+    Returns:
+        Configured FastAPI application
+    """
+    app = FastAPI(
+        title=title,
+        version=version,
+        description="""
+Minion Code Web API
+
+Provides streaming chat interface with:
+- SSE (Server-Sent Events) for real-time responses
+- A2A-style input_required for bidirectional interactions
+- Session management with full/incremental history modes
+
+## Endpoints
+
+### Sessions
+- `POST /api/sessions` - Create new session
+- `GET /api/sessions` - List active sessions
+- `GET /api/sessions/{id}` - Get session details
+- `GET /api/sessions/{id}/messages` - Get message history
+- `DELETE /api/sessions/{id}` - Delete session
+- `POST /api/sessions/{id}/abort` - Abort current task
+
+### Chat
+- `POST /api/chat/{session_id}` - Send message, receive SSE stream
+
+### Interactions
+- `POST /api/tasks/{task_id}/input` - Respond to input_required event
+- `POST /api/tasks/{task_id}/cancel` - Cancel pending interaction
+
+## SSE Event Types
+
+- `task_status` - Task state changes
+- `content` - Streaming text content
+- `thinking` - LLM reasoning content
+- `tool_call` - Tool invocation
+- `tool_result` - Tool execution result
+- `input_required` - Request for user input
+- `error` - Error message
+
+## History Modes
+
+- `full` - Each request creates new agent, loads full history (stateless, scalable)
+- `incremental` - Reuse agent, only send new message (stateful, low latency)
+        """,
+        docs_url="/docs",
+        redoc_url="/redoc",
+    )
+
+    # CORS configuration
+    if cors_origins is None:
+        cors_origins = [
+            "http://localhost:3000",
+            "http://localhost:5173",
+            "http://127.0.0.1:3000",
+            "http://127.0.0.1:5173",
+        ]
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=cors_origins,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Register routers
+    app.include_router(sessions_router)
+    app.include_router(chat_router)
+    app.include_router(interactions_router)
+
+    # Health check endpoint
+    @app.get("/health")
+    async def health_check():
+        return {"status": "ok"}
+
+    # Root endpoint
+    @app.get("/")
+    async def root():
+        return {"name": title, "version": version, "docs": "/docs", "health": "/health"}
+
+    return app
+
+
+def run_server(
+    host: str = "0.0.0.0",
+    port: int = 8000,
+    reload: bool = False,
+    log_level: str = "info",
+):
+    """
+    Run the web server.
+
+    Args:
+        host: Host to bind to
+        port: Port to listen on
+        reload: Enable auto-reload for development
+        log_level: Logging level
+    """
+    import uvicorn
+
+    logger.info(f"Starting Minion Code Web API on {host}:{port}")
+
+    uvicorn.run(
+        "minion_code.web.server:create_app",
+        factory=True,
+        host=host,
+        port=port,
+        reload=reload,
+        log_level=log_level,
+    )
+
+
+# For direct module execution
+if __name__ == "__main__":
+    run_server()

minion_code/web/services/__init__.py

@@ -0,0 +1,5 @@
+"""Web services."""
+
+from .session_manager import SessionManager, session_manager
+
+__all__ = ["SessionManager", "session_manager"]