monkeybot 2.1.1__py3-none-any.whl

monkeybot/gateway/sse/loop_port.py

@@ -0,0 +1,31 @@
+"""
+Injectable ports between the SSE gateway and the agent loop / usage store.
+"""
+
+from typing import Any, Protocol
+
+from monkeybot.core.types.content_blocks import ContentBlock
+
+
+class LoopPort(Protocol):
+    """Schedules a turn; implementations publish Agent events to the session bus."""
+
+    async def start_turn(
+        self,
+        session_id: str,
+        request_id: str,
+        user_content: list[ContentBlock],
+    ) -> None:
+        """Schedule background work; events MUST be published to that session's bus."""
+
+
+class UsagePort(Protocol):
+    """Returns usage aggregates for GET /sessions/{id}/usage."""
+
+    async def session_usage(
+        self,
+        session_id: str,
+        *,
+        since: str | None,
+    ) -> dict[str, Any]:
+        """Return JSON-serializable dict matching GET /usage body."""

monkeybot/gateway/sse/models.py

@@ -0,0 +1,177 @@
+"""
+Pydantic models and API errors for the v2 SSE gateway.
+"""
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+
+class ErrorBody(BaseModel):
+    """Error payload matching design contract 1b."""
+
+    code: str
+    message: str
+    request_id: str
+
+
+class ErrorEnvelope(BaseModel):
+    """Top-level error response `{ \"error\": ... }`."""
+
+    error: ErrorBody
+
+
+class APIError(Exception):
+    """Raised for API failures; maps to JSON error envelope via exception handler."""
+
+    def __init__(self, status_code: int, code: str, message: str, request_id: str) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.code = code
+        self.message = message
+        self.request_id = request_id
+
+
+class CreateSessionRequest(BaseModel):
+    """POST /sessions body."""
+
+    session_id: str | None = Field(
+        default=None,
+        max_length=128,
+        description="Client id; server generates UUID when omitted.",
+    )
+    agent_md: str | None = Field(default=None, description="Optional AGENT.md path override.")
+    model_provider: str | None = Field(
+        default=None,
+        description="Canonical or alias provider id (e.g. 'openai', 'gemini', 'vertex-claude'). None → server env default.",
+    )
+    model_name: str | None = Field(
+        default=None,
+        max_length=200,
+        description="Model id for the chosen provider. None → server env default.",
+    )
+
+
+class CreateSessionResponse(BaseModel):
+    """POST /sessions response (201)."""
+
+    session_id: str
+    created_at: int = Field(..., description="Unix time in milliseconds.")
+
+
+class ReplyBodyFields(BaseModel):
+    """Shared ``message`` / ``content`` fields for reply, steer, and queue."""
+
+    message: str | None = Field(default=None, max_length=32000)
+    content: list[dict[str, Any]] | None = None
+
+
+class ReplyRequest(ReplyBodyFields):
+    """POST /sessions/{id}/reply body."""
+
+    request_id: str
+
+
+class SteerRequest(ReplyBodyFields):
+    """POST /sessions/{id}/steer — mid-turn user injection (requires busy session)."""
+
+
+class QueueRequest(ReplyBodyFields):
+    """POST /sessions/{id}/queue — follow-up prompt drained when the session goes idle."""
+
+    request_id: str
+
+
+class AttachmentUploadResponse(BaseModel):
+    """POST /sessions/{id}/attachments response (201)."""
+
+    attachment_id: str
+    mime_type: str
+    size_bytes: int
+    filename: str
+    created_at: int
+
+
+class ReplyResponse(BaseModel):
+    """POST /sessions/{id}/reply response (200)."""
+
+    request_id: str
+
+
+class AdmissionAcceptedResponse(BaseModel):
+    """POST /steer or /queue acceptance."""
+
+    request_id: str
+    queue: Literal["steer", "follow_up"]
+    position: int
+
+
+class CancelRequest(BaseModel):
+    """POST /sessions/{id}/cancel body."""
+
+    request_id: str
+
+
+class ToolConfirmationPOST(BaseModel):
+    """POST /sessions/{id}/tool-confirmations/{tool_call_id} body."""
+
+    approved: bool
+    reason: str | None = None
+    always: bool = False
+    """When true with approved, remember this tool+resource for the rest of the session."""
+
+
+class ElicitationPOST(BaseModel):
+    """POST /sessions/{id}/elicitations/{id} body."""
+
+    user_data: Any | None = None
+
+
+class FrontendToolResultPOST(BaseModel):
+    """POST /sessions/{id}/frontend-tool-results/{tool_call_id} body."""
+
+    result: list[dict[str, Any]]
+    is_error: bool
+
+
+class HealthResponse(BaseModel):
+    """GET /health response."""
+
+    status: Literal["ok"]
+    version: Literal["2.0.0"]
+
+
+class SessionUsageResponse(BaseModel):
+    """GET /sessions/{id}/usage response."""
+
+    session_id: str
+    turns: int
+    input_tokens: int
+    output_tokens: int
+    cached_tokens: int
+    cache_read_tokens: int = 0
+    cache_creation_tokens: int = 0
+    cost_usd: float
+    period_start: int
+    period_end: int
+    last_prompt_tokens: int = Field(
+        0,
+        description="Input (prompt) tokens reported for the most recent completed turn in this session.",
+    )
+    estimated_prompt_tokens: int = Field(
+        0,
+        description="Peak pre-stream prompt input token count for the latest turn (provider count_tokens / OpenAI tiktoken); aligns with summarization checks.",
+    )
+    summarization_threshold_tokens: int = Field(
+        0,
+        description="``floor(MODEL_CONTEXT_WINDOW * 0.85)`` — same bar as sync summarization in the agent loop.",
+    )
+    context_window_tokens: int = Field(
+        1_000_000,
+        description="Configured model context window cap used for UI fill estimates (see MODEL_CONTEXT_WINDOW).",
+    )
+
+
+def error_payload_dict(code: str, message: str, request_id: str) -> dict[str, Any]:
+    """Build a JSON-serializable error body for JSONResponse."""
+    return {"error": {"code": code, "message": message, "request_id": request_id}}

monkeybot/gateway/sse/reply_body.py

@@ -0,0 +1,91 @@
+"""Normalize and validate POST /reply bodies into user ContentBlock lists."""
+
+from __future__ import annotations
+
+from monkeybot.core.attachments.config import max_attachments_per_reply
+from monkeybot.core.attachments.store import AttachmentStore
+from monkeybot.core.types.content_blocks import (
+    AttachmentRef,
+    ContentBlock,
+    File,
+    Image,
+    Text,
+)
+
+
+class ReplyBodyError(ValueError):
+    """Validation failure for reply body normalization."""
+
+    def __init__(self, code: str, message: str) -> None:
+        super().__init__(message)
+        self.code = code
+
+
+def normalize_reply_to_user_content(
+    *,
+    message: str | None,
+    content: list[dict[str, object]] | None,
+    session_id: str,
+    attachment_store: AttachmentStore | None,
+) -> list[ContentBlock]:
+    has_message = message is not None and message.strip() != ""
+    has_content = content is not None and len(content) > 0
+    if has_message and has_content:
+        raise ReplyBodyError("AMBIGUOUS_REPLY_BODY", "Send either message or content, not both")
+    if not has_message and not has_content:
+        raise ReplyBodyError("EMPTY_REPLY_BODY", "Reply must include message or content")
+
+    if has_message and not has_content:
+        return [Text(text=message or "")]
+
+    blocks: list[ContentBlock] = []
+    ref_count = 0
+    has_text = False
+    for raw in content or []:
+        if not isinstance(raw, dict):
+            raise ReplyBodyError("INVALID_CONTENT", "content blocks must be JSON objects")
+        tag = raw.get("type")
+        if tag in ("image", "file") and raw.get("data"):
+            raise ReplyBodyError(
+                "INLINE_ATTACHMENT_NOT_ALLOWED",
+                "Upload attachments via POST /attachments; use attachmentRef in content",
+            )
+        block = ContentBlock.from_dict(raw)
+        if isinstance(block, Image) or isinstance(block, File):
+            raise ReplyBodyError(
+                "INLINE_ATTACHMENT_NOT_ALLOWED",
+                "Upload attachments via POST /attachments; use attachmentRef in content",
+            )
+        if isinstance(block, Text):
+            if block.text.strip():
+                has_text = True
+            blocks.append(block)
+        elif isinstance(block, AttachmentRef):
+            ref_count += 1
+            if attachment_store is None or not attachment_store.exists(
+                session_id, block.attachment_id
+            ):
+                raise ReplyBodyError(
+                    "ATTACHMENT_NOT_FOUND",
+                    f"Unknown attachment_id: {block.attachment_id}",
+                )
+            blocks.append(block)
+        else:
+            raise ReplyBodyError(
+                "INVALID_CONTENT",
+                f"Unsupported content block type for /reply: {type(block).__name__}",
+            )
+
+    if ref_count > max_attachments_per_reply():
+        raise ReplyBodyError(
+            "TOO_MANY_ATTACHMENTS",
+            f"At most {max_attachments_per_reply()} attachments per reply",
+        )
+    if ref_count == 0 and not has_text:
+        raise ReplyBodyError(
+            "EMPTY_REPLY_BODY",
+            "Reply content must include text or at least one attachmentRef",
+        )
+    if not blocks:
+        raise ReplyBodyError("EMPTY_REPLY_BODY", "Reply content is empty")
+    return blocks