Deploy backend from GitHub 2d3455a8d65c9fd8cd30c3146d96419d0e627d6f

backend/app/api/models.py

@@ -43,3 +43,13 @@ class AnalyzeResponse(BaseModel):
 class HealthResponse(BaseModel):
     status: str = "ok"
     version: str = "1.0.0"
+
+
+class AssistRequest(BaseModel):
+    text: str = Field(..., min_length=10, max_length=50000, description="Text to rewrite/fix")
+    threat_score: Optional[float] = Field(None, ge=0.0, le=1.0, description="Threat score from analysis")
+
+
+class AssistResponse(BaseModel):
+    fixed_text: str
+    request_logs: List[str]

backend/app/api/routes.py

@@ -10,9 +10,13 @@ from datetime import datetime, timezone
 
 from fastapi import APIRouter, HTTPException
 
+import httpx
+
 from backend.app.api.models import (
     AnalyzeRequest,
     AnalyzeResponse,
+    AssistRequest,
+    AssistResponse,
     BulkAnalyzeRequest,
     ExplainabilityItem,
     SignalScores,
@@ -184,3 +188,61 @@ async def get_result(result_id: str):
         explainability=[ExplainabilityItem(**e) for e in (data.get("explainability") or [])],
         processing_time_ms=data.get("processing_time_ms"),
     )
+
+
+@router.post("/assist", response_model=AssistResponse)
+async def assist_text(request: AssistRequest):
+    """Call Groq API to propose a rewrite of flagged text to reduce AI threat indicators."""
+    if not settings.GROQ_API_KEY:
+        raise HTTPException(
+            status_code=503,
+            detail="AI Fixer is not configured: GROQ_API_KEY is missing",
+        )
+
+    rate_ok = await check_rate_limit("assist:global", limit=10)
+    if not rate_ok:
+        raise HTTPException(status_code=429, detail="Rate limit exceeded")
+
+    logs: list[str] = []
+    logs.append(f"Preparing rewrite request for Groq model: {settings.GROQ_MODEL}")
+
+    prompt = (
+        "You are a text editor. Rewrite the following text to sound more natural and human-authored "
+        "while preserving the original meaning and factual content. "
+        "Return only the rewritten text without any explanation or commentary.\n\n"
+        f"Original text:\n{request.text}"
+    )
+
+    try:
+        logs.append("Sending request to Groq API…")
+        async with httpx.AsyncClient(timeout=30.0) as http_client:
+            response = await http_client.post(
+                f"{settings.GROQ_BASE_URL}/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {settings.GROQ_API_KEY}",
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "model": settings.GROQ_MODEL,
+                    "messages": [{"role": "user", "content": prompt}],
+                    "max_tokens": 8192,
+                    "temperature": 0.7,
+                },
+            )
+            response.raise_for_status()
+            data = response.json()
+            fixed_text = data["choices"][0]["message"]["content"].strip()
+            logs.append("Groq model returned rewritten text successfully.")
+    except httpx.TimeoutException:
+        logger.warning("Groq API timeout in /api/assist")
+        raise HTTPException(status_code=504, detail="AI Fixer request timed out")
+    except httpx.HTTPStatusError as e:
+        logger.warning("Groq API error in /api/assist", status_code=e.response.status_code)
+        raise HTTPException(
+            status_code=502, detail=f"AI Fixer upstream error: {e.response.status_code}"
+        )
+    except Exception as e:
+        logger.warning("Unexpected error in /api/assist", error=str(e))
+        raise HTTPException(status_code=500, detail="AI Fixer failed unexpectedly")
+
+    return AssistResponse(fixed_text=fixed_text, request_logs=logs)

backend/app/db/firestore.py

@@ -21,6 +21,7 @@ from typing import Any
 
 import firebase_admin
 from firebase_admin import credentials, firestore as fb_firestore
+import google.auth.exceptions
 
 from backend.app.core.config import settings
 from backend.app.core.logging import get_logger
@@ -74,6 +75,9 @@ async def save_document(collection: str, doc_id: str, data: dict) -> bool:
     try:
         _db.collection(collection).document(doc_id).set(data)
         return True
+    except google.auth.exceptions.RefreshError as e:
+        logger.debug("Firestore save_document skipped – credential refresh failed", collection=collection, doc_id=doc_id, error=str(e))
+        return False
     except Exception as e:
         logger.warning("Firestore save_document failed", collection=collection, doc_id=doc_id, error=str(e))
         return False
@@ -86,6 +90,9 @@ async def get_document(collection: str, doc_id: str) -> dict | None:
     try:
         doc = _db.collection(collection).document(doc_id).get()
         return doc.to_dict() if doc.exists else None
+    except google.auth.exceptions.RefreshError as e:
+        logger.debug("Firestore get_document skipped – credential refresh failed", collection=collection, doc_id=doc_id, error=str(e))
+        return None
     except Exception as e:
         logger.warning("Firestore get_document failed", collection=collection, doc_id=doc_id, error=str(e))
         return None

backend/tests/test_api.py

@@ -118,8 +118,109 @@ class TestAnalyzeEndpoint:
         assert response.status_code == 422
 
 
-class TestAttackSimulations:
+class TestAssistEndpoint:
+    def test_assist_no_api_key_returns_503(self, client):
+        """When GROQ_API_KEY is not set, /api/assist should return 503."""
+        from backend.app.core import config
+        original = config.settings.GROQ_API_KEY
+        try:
+            config.settings.GROQ_API_KEY = ""
+            response = client.post(
+                "/api/assist",
+                json={"text": "This is a test text that needs to be fixed by the AI assistant."},
+            )
+            assert response.status_code == 503
+            assert "GROQ_API_KEY" in response.json()["detail"]
+        finally:
+            config.settings.GROQ_API_KEY = original
+
+    @patch("backend.app.api.routes.check_rate_limit", new_callable=AsyncMock, return_value=True)
+    @patch("backend.app.api.routes.httpx.AsyncClient")
+    def test_assist_returns_fixed_text(self, mock_http_cls, mock_rate, client):
+        """When Groq API responds, /api/assist should return fixed_text and logs."""
+        from backend.app.core import config
+        original = config.settings.GROQ_API_KEY
+        try:
+            config.settings.GROQ_API_KEY = "test-groq-key"
+            # Set up mock response
+            mock_response = MagicMock()
+            mock_response.json.return_value = {
+                "choices": [{"message": {"content": "This is the improved text."}}]
+            }
+            mock_response.raise_for_status = MagicMock()
+            mock_http_instance = MagicMock()
+            mock_http_instance.__aenter__ = AsyncMock(return_value=mock_http_instance)
+            mock_http_instance.__aexit__ = AsyncMock(return_value=False)
+            mock_http_instance.post = AsyncMock(return_value=mock_response)
+            mock_http_cls.return_value = mock_http_instance
+
+            response = client.post(
+                "/api/assist",
+                json={"text": "This is a test text that needs to be fixed by the AI assistant."},
+            )
+            assert response.status_code == 200
+            data = response.json()
+            assert data["fixed_text"] == "This is the improved text."
+            assert isinstance(data["request_logs"], list)
+            assert len(data["request_logs"]) > 0
+        finally:
+            config.settings.GROQ_API_KEY = original
 
+    @patch("backend.app.api.routes.check_rate_limit", new_callable=AsyncMock, return_value=False)
+    def test_assist_rate_limited(self, mock_rate, client):
+        """When rate limit is exceeded, /api/assist should return 429."""
+        from backend.app.core import config
+        original = config.settings.GROQ_API_KEY
+        try:
+            config.settings.GROQ_API_KEY = "test-groq-key"
+            response = client.post(
+                "/api/assist",
+                json={"text": "This is a test text that needs to be fixed."},
+            )
+            assert response.status_code == 429
+        finally:
+            config.settings.GROQ_API_KEY = original
+
+
+class TestFirestoreRefreshError:
+    """Verify RefreshError is logged at DEBUG, not WARNING."""
+
+    @pytest.mark.asyncio
+    async def test_save_document_refresh_error_returns_false(self):
+        """RefreshError in save_document should return False without raising."""
+        import google.auth.exceptions
+        from unittest.mock import MagicMock, patch
+
+        mock_db = MagicMock()
+        mock_db.collection.return_value.document.return_value.set.side_effect = (
+            google.auth.exceptions.RefreshError("invalid_grant: Invalid JWT Signature")
+        )
+
+        with patch("backend.app.db.firestore._enabled", True), \
+             patch("backend.app.db.firestore._db", mock_db):
+            from backend.app.db.firestore import save_document
+            result = await save_document("test_col", "test_doc", {"key": "value"})
+            assert result is False
+
+    @pytest.mark.asyncio
+    async def test_get_document_refresh_error_returns_none(self):
+        """RefreshError in get_document should return None without raising."""
+        import google.auth.exceptions
+        from unittest.mock import MagicMock, patch
+
+        mock_db = MagicMock()
+        mock_db.collection.return_value.document.return_value.get.side_effect = (
+            google.auth.exceptions.RefreshError("invalid_grant: Invalid JWT Signature")
+        )
+
+        with patch("backend.app.db.firestore._enabled", True), \
+             patch("backend.app.db.firestore._db", mock_db):
+            from backend.app.db.firestore import get_document
+            result = await get_document("test_col", "test_doc")
+            assert result is None
+
+
+class TestAttackSimulations:
     @patch("backend.app.api.routes.check_rate_limit", new_callable=AsyncMock, return_value=True)
     @patch("backend.app.api.routes.detect_ai_text", new_callable=AsyncMock, return_value=0.95)
     @patch("backend.app.api.routes.compute_perplexity", new_callable=AsyncMock, return_value=0.8)