claude-smart 0.2.46 → 0.2.48

package/plugin/vendor/reflexio/reflexio/server/routes/interactions.py

@@ -0,0 +1,259 @@
+"""Interaction route handlers (extracted from api.py, Tier3 A2)."""
+
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    pass
+
+from fastapi import (
+    APIRouter,
+    BackgroundTasks,
+    Depends,
+    Request,
+)
+
+from reflexio.models.api_schema.retriever_schema import (
+    GetInteractionsRequest,
+    GetInteractionsViewResponse,
+    GetRequestsRequest,
+    GetRequestsViewResponse,
+    RequestDataView,
+    SessionView,
+)
+from reflexio.models.api_schema.service_schemas import (
+    BulkDeleteResponse,
+    DeleteRequestRequest,
+    DeleteRequestResponse,
+    DeleteRequestsByIdsRequest,
+    DeleteSessionRequest,
+    DeleteSessionResponse,
+    DeleteUserInteractionRequest,
+    DeleteUserInteractionResponse,
+    PublishUserInteractionRequest,
+    PublishUserInteractionResponse,
+)
+from reflexio.models.api_schema.ui.converters import (
+    to_interaction_view,
+)
+from reflexio.server.api_endpoints import (
+    publisher_api,
+)
+from reflexio.server.auth import (
+    default_billing_gate,
+    default_get_org_id,
+)
+from reflexio.server.cache import reflexio_cache
+from reflexio.server.rate_limit import limiter
+from reflexio.server.routes._common import _run_limited_api
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+
+@router.post(
+    "/api/publish_interaction",
+    response_model=PublishUserInteractionResponse,
+    response_model_exclude_none=True,
+)
+@limiter.limit("60/minute")  # Rate limit for write operations
+def publish_user_interaction(
+    request: Request,
+    payload: PublishUserInteractionRequest,
+    background_tasks: BackgroundTasks,
+    org_id: str = Depends(default_get_org_id),
+    wait_for_response: bool = False,
+    _gate: None = Depends(default_billing_gate("learnings_generated")),  # noqa: B008
+) -> PublishUserInteractionResponse:
+    if wait_for_response:
+        # Sync callers wait for the real result, so preserve bounded backpressure
+        # before any storage side effects. The inner service limiter is disabled
+        # because this route already owns the publish slot.
+        return _run_limited_api(
+            org_id,
+            "publish",
+            lambda: publisher_api.add_user_interaction(
+                org_id=org_id,
+                request=payload,
+                use_publish_limiter=False,
+            ),
+        )
+
+    def _publish_task() -> None:
+        try:
+            publisher_api.add_user_interaction(
+                org_id=org_id,
+                request=payload,
+                defer_learning=True,
+            )
+        except Exception:
+            logger.exception("Background publish failed for org %s", org_id)
+
+    # Run in background — caller gets immediate acknowledgement
+    background_tasks.add_task(_publish_task)
+    return PublishUserInteractionResponse(
+        success=True, message="Interaction queued for processing"
+    )
+
+
+@router.delete(
+    "/api/delete_interaction",
+    response_model=DeleteUserInteractionResponse,
+    response_model_exclude_none=True,
+)
+def delete_interaction(
+    request: DeleteUserInteractionRequest,
+    org_id: str = Depends(default_get_org_id),
+) -> DeleteUserInteractionResponse:
+    return publisher_api.delete_user_interaction(org_id=org_id, request=request)
+
+
+@router.delete(
+    "/api/delete_request",
+    response_model=DeleteRequestResponse,
+    response_model_exclude_none=True,
+)
+def delete_request(
+    request: DeleteRequestRequest,
+    org_id: str = Depends(default_get_org_id),
+) -> DeleteRequestResponse:
+    return publisher_api.delete_request(org_id=org_id, request=request)
+
+
+@router.delete(
+    "/api/delete_session",
+    response_model=DeleteSessionResponse,
+    response_model_exclude_none=True,
+)
+def delete_session(
+    request: DeleteSessionRequest,
+    org_id: str = Depends(default_get_org_id),
+) -> DeleteSessionResponse:
+    return publisher_api.delete_session(org_id=org_id, request=request)
+
+
+@router.delete(
+    "/api/delete_requests_by_ids",
+    response_model=BulkDeleteResponse,
+    response_model_exclude_none=True,
+)
+def delete_requests_by_ids(
+    request: DeleteRequestsByIdsRequest,
+    org_id: str = Depends(default_get_org_id),
+) -> BulkDeleteResponse:
+    """Delete multiple requests by their IDs.
+
+    Args:
+        request (DeleteRequestsByIdsRequest): Request containing list of request IDs to delete
+        org_id (str): Organization ID
+
+    Returns:
+        BulkDeleteResponse: Response containing success status and deleted count
+    """
+    return publisher_api.delete_requests_by_ids(org_id=org_id, request=request)
+
+
+@router.delete(
+    "/api/delete_all_interactions",
+    response_model=BulkDeleteResponse,
+    response_model_exclude_none=True,
+)
+@limiter.limit("10/minute")
+def delete_all_interactions(
+    request: Request,
+    org_id: str = Depends(default_get_org_id),
+) -> BulkDeleteResponse:
+    """Delete all requests and their associated interactions.
+
+    Args:
+        org_id (str): Organization ID
+
+    Returns:
+        BulkDeleteResponse: Response containing success status and deleted count
+    """
+    return publisher_api.delete_all_interactions_bulk(org_id=org_id)
+
+
+@router.post(
+    "/api/get_interactions",
+    response_model=GetInteractionsViewResponse,
+    response_model_exclude_none=True,
+)
+def get_interactions(
+    request: GetInteractionsRequest,
+    org_id: str = Depends(default_get_org_id),
+) -> GetInteractionsViewResponse:
+    response = reflexio_cache.get_reflexio(org_id=org_id).get_interactions(request)
+    return GetInteractionsViewResponse(
+        success=response.success,
+        interactions=[to_interaction_view(i) for i in response.interactions],
+        msg=response.msg,
+    )
+
+
+@router.get(
+    "/api/get_all_interactions",
+    response_model=GetInteractionsViewResponse,
+    response_model_exclude_none=True,
+)
+@limiter.limit("30/minute")
+def get_all_interactions(
+    request: Request,
+    limit: int = 100,
+    org_id: str = Depends(default_get_org_id),
+) -> GetInteractionsViewResponse:
+    """Get all user interactions across all users.
+
+    Args:
+        limit (int, optional): Maximum number of interactions to return. Defaults to 100.
+        org_id (str): Organization ID
+
+    Returns:
+        GetInteractionsViewResponse: Response containing all user interactions
+    """
+    reflexio = reflexio_cache.get_reflexio(org_id=org_id)
+    response = reflexio.get_all_interactions(limit=limit)
+    return GetInteractionsViewResponse(
+        success=response.success,
+        interactions=[to_interaction_view(i) for i in response.interactions],
+        msg=response.msg,
+    )
+
+
+@router.post(
+    "/api/get_requests",
+    response_model=GetRequestsViewResponse,
+    response_model_exclude_none=True,
+)
+def get_requests_endpoint(
+    request: GetRequestsRequest,
+    org_id: str = Depends(default_get_org_id),
+) -> GetRequestsViewResponse:
+    """Get requests with their associated interactions.
+
+    Args:
+        request (GetRequestsRequest): The get request
+        org_id (str): Organization ID
+
+    Returns:
+        GetRequestsViewResponse: Response containing requests with their interactions
+    """
+    internal_response = reflexio_cache.get_reflexio(org_id=org_id).get_requests(request)
+    return GetRequestsViewResponse(
+        success=internal_response.success,
+        sessions=[
+            SessionView(
+                session_id=s.session_id,
+                requests=[
+                    RequestDataView(
+                        request=rd.request,
+                        interactions=[to_interaction_view(i) for i in rd.interactions],
+                    )
+                    for rd in s.requests
+                ],
+            )
+            for s in internal_response.sessions
+        ],
+        has_more=internal_response.has_more,
+        msg=internal_response.msg,
+    )