mindroom 0.0.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

mindroom/api/matrix_operations.py

@@ -0,0 +1,219 @@
+"""API endpoints for Matrix operations."""
+
+import asyncio
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from mindroom.constants import MATRIX_HOMESERVER
+from mindroom.logging_config import get_logger
+from mindroom.matrix.client import get_joined_rooms, get_room_name, leave_room
+from mindroom.matrix.rooms import resolve_room_aliases
+from mindroom.matrix.users import create_agent_user, login_agent_user
+
+logger = get_logger(__name__)
+
+router = APIRouter(prefix="/api/matrix", tags=["matrix"])
+
+
+class RoomLeaveRequest(BaseModel):
+    """Request to leave a room."""
+
+    agent_id: str
+    room_id: str
+
+
+class RoomInfo(BaseModel):
+    """Information about a room."""
+
+    room_id: str
+    name: str | None = None
+
+
+class AgentRoomsResponse(BaseModel):
+    """Response containing agent rooms information."""
+
+    agent_id: str
+    display_name: str
+    configured_rooms: list[str]
+    joined_rooms: list[str]
+    unconfigured_rooms: list[str]
+    unconfigured_room_details: list[RoomInfo] = []
+
+
+class AllAgentsRoomsResponse(BaseModel):
+    """Response containing all agents' room information."""
+
+    agents: list[AgentRoomsResponse]
+
+
+async def get_agent_matrix_rooms(agent_id: str, agent_data: dict[str, Any]) -> AgentRoomsResponse:
+    """Get Matrix rooms for a specific agent.
+
+    Args:
+        agent_id: The agent identifier
+        agent_data: The agent configuration data
+
+    Returns:
+        AgentRoomsResponse with room information
+
+    """
+    # Create or get the agent user
+    agent_user = await create_agent_user(
+        MATRIX_HOMESERVER,
+        agent_id,
+        agent_data.get("display_name", agent_id),
+    )
+
+    # Login and get the client
+    client = await login_agent_user(MATRIX_HOMESERVER, agent_user)
+
+    # Get all joined rooms from Matrix
+    joined_rooms = await get_joined_rooms(client) or []
+
+    # Get configured rooms from config (these are aliases like "lobby", "analysis")
+    configured_room_aliases = agent_data.get("rooms", [])
+
+    # Resolve room aliases to room IDs for comparison
+    configured_room_ids = resolve_room_aliases(configured_room_aliases)
+
+    # Calculate unconfigured rooms (joined but not in config)
+    unconfigured_rooms = [room for room in joined_rooms if room not in configured_room_ids]
+
+    # Get room names for unconfigured rooms
+    unconfigured_room_details = []
+    for room_id in unconfigured_rooms:
+        room_name = await get_room_name(client, room_id)
+        unconfigured_room_details.append(RoomInfo(room_id=room_id, name=room_name))
+
+    await client.close()
+
+    return AgentRoomsResponse(
+        agent_id=agent_id,
+        display_name=agent_data.get("display_name", agent_id),
+        configured_rooms=configured_room_ids,
+        joined_rooms=joined_rooms,
+        unconfigured_rooms=unconfigured_rooms,
+        unconfigured_room_details=unconfigured_room_details,
+    )
+
+
+@router.get("/agents/rooms")
+async def get_all_agents_rooms() -> AllAgentsRoomsResponse:
+    """Get room information for all agents.
+
+    Returns information about configured rooms, joined rooms,
+    and unconfigured rooms (joined but not in config) for each agent.
+    """
+    from .main import config, config_lock  # noqa: PLC0415
+
+    agents_rooms = []
+
+    with config_lock:
+        agents = config.get("agents", {})
+
+    # Gather room information for all agents concurrently
+    tasks = [get_agent_matrix_rooms(agent_id, agent_data) for agent_id, agent_data in agents.items()]
+    agents_rooms = await asyncio.gather(*tasks)
+
+    return AllAgentsRoomsResponse(agents=agents_rooms)
+
+
+@router.get("/agents/{agent_id}/rooms")
+async def get_agent_rooms(agent_id: str) -> AgentRoomsResponse:
+    """Get room information for a specific agent.
+
+    Args:
+        agent_id: The agent identifier
+
+    Returns:
+        Room information for the agent
+
+    Raises:
+        HTTPException: If agent not found or error occurs
+
+    """
+    from .main import config, config_lock  # noqa: PLC0415
+
+    with config_lock:
+        agents = config.get("agents", {})
+        if agent_id not in agents:
+            raise HTTPException(status_code=404, detail=f"Agent {agent_id} not found")
+        agent_data = agents[agent_id]
+
+    return await get_agent_matrix_rooms(agent_id, agent_data)
+
+
+@router.post("/rooms/leave")
+async def leave_room_endpoint(request: RoomLeaveRequest) -> dict[str, bool]:
+    """Make an agent leave a specific room.
+
+    Args:
+        request: Contains agent_id and room_id
+
+    Returns:
+        Success status
+
+    Raises:
+        HTTPException: If agent not found or leave operation fails
+
+    """
+    from .main import config, config_lock  # noqa: PLC0415
+
+    with config_lock:
+        agents = config.get("agents", {})
+        if request.agent_id not in agents:
+            raise HTTPException(status_code=404, detail=f"Agent {request.agent_id} not found")
+
+    # Get agent configuration
+    agent_data = agents[request.agent_id]
+
+    # Create or get the agent user
+    agent_user = await create_agent_user(
+        MATRIX_HOMESERVER,
+        request.agent_id,
+        agent_data.get("display_name", request.agent_id),
+    )
+
+    # Login and get the client
+    client = await login_agent_user(MATRIX_HOMESERVER, agent_user)
+
+    # Leave the room
+    success = await leave_room(client, request.room_id)
+
+    # Close the client connection
+    await client.close()
+
+    if not success:
+        raise HTTPException(status_code=500, detail=f"Failed to leave room {request.room_id}")
+    return {"success": True}
+
+
+@router.post("/rooms/leave-bulk")
+async def leave_rooms_bulk(requests: list[RoomLeaveRequest]) -> dict[str, Any]:
+    """Make multiple agents leave multiple rooms.
+
+    Args:
+        requests: List of leave requests
+
+    Returns:
+        Results for each request
+
+    """
+    results = []
+    for request in requests:
+        try:
+            await leave_room_endpoint(request)
+            results.append({"agent_id": request.agent_id, "room_id": request.room_id, "success": True})
+        except HTTPException as e:
+            results.append(
+                {
+                    "agent_id": request.agent_id,
+                    "room_id": request.room_id,
+                    "success": False,
+                    "error": e.detail,
+                },
+            )
+
+    return {"results": results, "success": all(r["success"] for r in results)}

mindroom/api/tools.py

@@ -0,0 +1,94 @@
+"""API endpoints for tools information."""
+
+import json
+from pathlib import Path
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+import mindroom
+from mindroom.credentials import CredentialsManager, get_credentials_manager
+
+from .google_tools_helper import check_google_tool_configured
+
+router = APIRouter(prefix="/api/tools", tags=["tools"])
+
+
+class ToolsResponse(BaseModel):
+    """Response containing all registered tools."""
+
+    tools: list[dict]
+
+
+def _check_homeassistant_configured(tool_name: str, manager: CredentialsManager) -> bool:
+    """Check if HomeAssistant is configured."""
+    if tool_name == "homeassistant":
+        ha_creds = manager.load_credentials("homeassistant")
+        if not ha_creds:
+            return False
+        # Check for the fields that HomeAssistantTools actually uses
+        has_url = "instance_url" in ha_creds
+        has_token = "access_token" in ha_creds or "long_lived_token" in ha_creds
+        return has_url and has_token
+    return False
+
+
+def _check_standard_tool_configured(tool: dict[str, Any], manager: CredentialsManager) -> bool:
+    """Check if a standard tool with config_fields is configured."""
+    if not tool.get("config_fields"):
+        return False
+
+    credentials = manager.load_credentials(tool["name"])
+    if not credentials:
+        return False
+
+    # Check if all required fields are present
+    required_fields = [field["name"] for field in tool.get("config_fields", []) if field.get("required", True)]
+    return all(field in credentials for field in required_fields)
+
+
+@router.get("")
+async def get_registered_tools() -> ToolsResponse:
+    """Get all registered tools from mindroom.
+
+    This reads from a pre-generated JSON file that is created by the test suite.
+    The JSON file is generated by tests/test_tools_metadata.py and committed to the repo.
+    It also checks if credentials exist for tools that require them.
+    """
+    # Path to the generated JSON file - use package location for reliability
+    package_dir = Path(mindroom.__file__).parent
+    json_path = package_dir / "tools_metadata.json"
+
+    if not json_path.exists():
+        raise HTTPException(
+            status_code=500,
+            detail="tools_metadata.json not found. Run 'pytest tests/test_tools_metadata.py' to generate it.",
+        )
+
+    with json_path.open() as f:
+        data = json.load(f)
+        tools = data["tools"]
+
+    # Get credentials manager to check if tools are configured
+    manager = get_credentials_manager()
+
+    # Update status for tools that require configuration
+    for tool in tools:
+        tool_name = tool["name"]
+        if tool.get("status") == "requires_config":
+            # Check if tool has delegated auth
+            auth_provider = tool.get("auth_provider")
+            if auth_provider:
+                # Check if the auth provider is configured
+                provider_creds = manager.load_credentials(auth_provider)
+                if provider_creds and (
+                    (auth_provider == "google" and check_google_tool_configured(tool_name, provider_creds))
+                    or auth_provider != "google"
+                ):
+                    tool["status"] = "available"
+            # Check other configured tools
+            elif _check_homeassistant_configured(tool_name, manager) or _check_standard_tool_configured(tool, manager):
+                tool["status"] = "available"
+
+    return ToolsResponse(tools=tools)

mindroom/background_tasks.py

@@ -0,0 +1,87 @@
+"""Background task management for non-blocking operations."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING, Any
+
+from .logging_config import get_logger
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Coroutine
+
+logger = get_logger(__name__)
+
+# Global set to track background tasks and prevent them from being garbage collected
+_background_tasks: set[asyncio.Task[Any]] = set()
+
+
+def create_background_task(
+    coro: Coroutine[Any, Any, Any],
+    name: str | None = None,
+    error_handler: Callable[[Exception], None] | None = None,
+) -> asyncio.Task[Any]:
+    """Create a background task that won't block the main execution.
+
+    Args:
+        coro: The coroutine to run in the background
+        name: Optional name for the task (for logging)
+        error_handler: Optional error handler function
+
+    Returns:
+        The created task
+
+    """
+    task: asyncio.Task[Any] = asyncio.create_task(coro)
+    if name:
+        task.set_name(name)
+
+    # Add to global set to prevent garbage collection
+    _background_tasks.add(task)
+
+    # Add completion callback to remove from set and handle errors
+    def _task_done_callback(task: asyncio.Task[Any]) -> None:
+        _background_tasks.discard(task)
+        try:
+            # This will raise if the task had an exception
+            task.result()
+        except asyncio.CancelledError:
+            # Task was cancelled, this is fine
+            pass
+        except Exception as e:
+            task_name = task.get_name() if hasattr(task, "get_name") else "unknown"
+            logger.exception("Background task failed", task_name=task_name, error=str(e))
+            if error_handler:
+                try:
+                    error_handler(e)
+                except Exception as handler_error:
+                    logger.exception("Error handler for task failed", task_name=task_name, error=str(handler_error))
+
+    task.add_done_callback(_task_done_callback)
+    return task
+
+
+async def wait_for_background_tasks(timeout: float | None = None) -> None:  # noqa: ASYNC109
+    """Wait for all background tasks to complete.
+
+    Args:
+        timeout: Optional timeout in seconds
+
+    """
+    if not _background_tasks:
+        return
+
+    try:
+        await asyncio.wait_for(asyncio.gather(*_background_tasks, return_exceptions=True), timeout=timeout)
+    except TimeoutError:
+        logger.warning(f"Background tasks did not complete within {timeout} seconds")
+        # Cancel remaining tasks
+        for task in _background_tasks:
+            task.cancel()
+        # Wait for cancellation to complete
+        await asyncio.gather(*_background_tasks, return_exceptions=True)
+
+
+def get_background_task_count() -> int:
+    """Get the number of currently running background tasks."""
+    return len(_background_tasks)