Sync backend to GitHub d13146e: Roll main back to 4.9.0 (revert the 5.0.0 merge)

backend/core/config.py

@@ -172,18 +172,7 @@ class Settings:
     SHARED_KEY_DAILY_LIMIT = int(os.getenv("SHARED_KEY_DAILY_LIMIT", "15"))
     BYOK_DAILY_LIMIT = int(os.getenv("BYOK_DAILY_LIMIT", "1000"))
 
-    # Anonymous tier: an install that has not signed in. Quick rewrites only,
-    # no memory, nothing stored. Two caps: one per install, and one across all
-    # anonymous installs together, because a token is free to mint and the
-    # global cap is what actually bounds spend on the server key.
-    ANON_DAILY_LIMIT = int(os.getenv("ANON_DAILY_LIMIT", "10"))
-    ANON_GLOBAL_DAILY_LIMIT = int(os.getenv("ANON_GLOBAL_DAILY_LIMIT", "2000"))
-    ANON_TOKEN_DAYS = int(os.getenv("ANON_TOKEN_DAYS", "90"))
-    # New anonymous tokens per client address per hour.
-    ANON_MINT_PER_HOUR = int(os.getenv("ANON_MINT_PER_HOUR", "10"))
-
     TIER_LIMITS = {
-        "anon":       ANON_DAILY_LIMIT,
         "free":       int(os.getenv("FREE_TIER_LIMIT", str(SHARED_KEY_DAILY_LIMIT))),
         "byok":       int(os.getenv("BYOK_DAILY_LIMIT", "1000")),
         "pro":        int(os.getenv("PRO_TIER_LIMIT", "200")),

backend/core/ratelimit.py

@@ -25,7 +25,7 @@ from collections import defaultdict, deque
 from fastapi import Depends, HTTPException
 
 from .config import settings
-from .security import verify_jwt, verify_jwt_or_anon
+from .security import verify_jwt
 
 _lock = threading.Lock()
 _hits: dict = defaultdict(deque)   # bucket key -> deque[timestamp]
@@ -62,16 +62,14 @@ def _check(key: str, limit: int, window: int) -> tuple:
         return True, 0
 
 
-def limit(rule: str, scope: str, allow_anon: bool = False):
+def limit(rule: str, scope: str):
     """
     Build a dependency enforcing `rule` for the authenticated user.
 
     Depends on verify_jwt, so an unauthenticated caller is still rejected with
     the usual 401 before any counting happens.
     """
-    auth = verify_jwt_or_anon if allow_anon else verify_jwt
-
-    def dependency(user_id: str = Depends(auth)) -> str:
+    def dependency(user_id: str = Depends(verify_jwt)) -> str:
         limit_n, window = parse_rule(rule)
         allowed, retry_after = _check(f"{scope}:{user_id}", limit_n, window)
         if not allowed:
@@ -84,6 +82,5 @@ def limit(rule: str, scope: str, allow_anon: bool = False):
     return dependency
 
 
-# The rewrite is the one thing an install can do before signing in.
-enhance_limit = limit(settings.RATE_LIMIT_ENHANCE, "enhance", allow_anon=True)
+enhance_limit = limit(settings.RATE_LIMIT_ENHANCE, "enhance")
 voice_limit = limit(settings.RATE_LIMIT_VOICE, "voice")

backend/core/security.py

@@ -1,5 +1,4 @@
 
-import uuid
 from datetime import datetime, timedelta
 import jwt
 from fastapi import HTTPException, Depends
@@ -8,16 +7,6 @@ from .config import settings
 
 security_scheme = HTTPBearer()
 
-# Anonymous installs get a signed token whose subject carries this prefix.
-# Google accounts are uuid4 strings, so the two can never collide, and the
-# prefix lets every route tell them apart without a database read.
-ANON_PREFIX = "anon_"
-
-
-def is_anonymous(user_id: str) -> bool:
-    return str(user_id or "").startswith(ANON_PREFIX)
-
-
 def create_jwt_token(user_id: str, email: str) -> str:
     """Creates a signed JWT with 7-day expiration."""
     expiration = datetime.utcnow() + timedelta(days=7)
@@ -28,47 +17,13 @@ def create_jwt_token(user_id: str, email: str) -> str:
     }
     return jwt.encode(payload, settings.JWT_SECRET, algorithm=settings.ALGORITHM)
 
-
-def create_anon_token() -> tuple:
-    """
-    A token for an install that has not signed in. Returns (token, user_id).
-
-    It names no person and nothing is stored against it: it only lets the
-    server count one install's free rewrites. No email, so /auth/refresh
-    refuses it; when it lapses the extension asks for a new one.
-    """
-    user_id = f"{ANON_PREFIX}{uuid.uuid4().hex}"
-    payload = {
-        "sub": user_id,
-        "anon": True,
-        "exp": datetime.utcnow() + timedelta(days=settings.ANON_TOKEN_DAYS),
-    }
-    return jwt.encode(payload, settings.JWT_SECRET, algorithm=settings.ALGORITHM), user_id
-
-
-def _decode_subject(credentials: HTTPAuthorizationCredentials) -> str:
+def verify_jwt(credentials: HTTPAuthorizationCredentials = Depends(security_scheme)):
+    """Dependency to verify JWT header."""
     token = credentials.credentials
     try:
         payload = jwt.decode(token, settings.JWT_SECRET, algorithms=[settings.ALGORITHM])
-        return payload["sub"]
+        return payload["sub"] # Returns user_id
     except jwt.ExpiredSignatureError:
         raise HTTPException(status_code=401, detail="Token expired")
-    except (jwt.InvalidTokenError, KeyError):
+    except jwt.InvalidTokenError:
         raise HTTPException(status_code=401, detail="Invalid token")
-
-
-def verify_jwt(credentials: HTTPAuthorizationCredentials = Depends(security_scheme)):
-    """
-    A signed-in user's id. Anonymous tokens are refused here, so every route
-    that keeps data (library, history, feedback, voice) needs an account
-    without each one having to remember to check.
-    """
-    user_id = _decode_subject(credentials)
-    if is_anonymous(user_id):
-        raise HTTPException(status_code=403, detail="sign_in_required")
-    return user_id
-
-
-def verify_jwt_or_anon(credentials: HTTPAuthorizationCredentials = Depends(security_scheme)):
-    """A signed-in or anonymous id. Only for the free rewrite and its usage count."""
-    return _decode_subject(credentials)

backend/main.py

@@ -136,7 +136,7 @@ def startup_db_client():
     env_label = "🔧 DEVELOPMENT" if not settings.is_production else "🚀 PRODUCTION"
     cors_label = "* (all origins)" if not settings.is_production else ", ".join(settings.cors_origins) or "(none configured!)"
     logger.info(f"\n{'='*60}")
-    logger.info(f"🚀 Prompt Memory v5.0.0 — Server Ready!")
+    logger.info(f"🚀 Prompt Memory v4.0 — Server Ready!")
     logger.info(f"   Environment: {env_label}")
     logger.info(f"   CORS Origins: {cors_label}")
     logger.info(f"   http://localhost:8000")
@@ -162,7 +162,7 @@ def health_check():
     return {
         "status": "running",
         "service": "Context-Aware Prompt Engine",
-        "version": "5.0.0",
+        "version": "4.1",
         "environment": "production" if settings.is_production else "development",
         "cors_origins": len(settings.cors_origins),
     }

backend/routers/auth.py

@@ -4,13 +4,12 @@ import uuid
 import secrets
 import httpx
 import jwt
-from fastapi import APIRouter, HTTPException, Depends, Request
+from fastapi import APIRouter, HTTPException, Depends
 from fastapi.responses import HTMLResponse
 from ..models.schemas import RefreshRequest
 from ..core.config import settings
 from ..core.database import MongoDB, in_memory_users
-from ..core.security import create_jwt_token, create_anon_token
-from ..core import ratelimit
+from ..core.security import create_jwt_token
 
 router = APIRouter()
 _oauth_state_store = {}   # state -> expiry.  CSRF protection for OAuth.
@@ -183,38 +182,6 @@ def google_poll(state: str):
     return {"status": "ready", **entry[1]}
 
 
-# --- ANONYMOUS INSTALLS ---
-
-def _client_address(request: Request) -> str:
-    """The caller's address. The Space sits behind a proxy, so the first
-    X-Forwarded-For hop is the real client; the socket peer is the proxy."""
-    forwarded = request.headers.get("x-forwarded-for", "")
-    if forwarded:
-        return forwarded.split(",")[0].strip()
-    return request.client.host if request.client else "unknown"
-
-
-@router.post("/auth/anonymous")
-def anonymous_token(request: Request):
-    """
-    A token for an install that has not signed in, so a new user's first
-    rewrite needs no account and no API key. Nothing is stored. Minting is
-    capped per address; the real bound on spend is the global anonymous cap
-    in /enhance.
-    """
-    allowed, retry_after = ratelimit._check(
-        f"anon_mint:{_client_address(request)}", settings.ANON_MINT_PER_HOUR, 3600
-    )
-    if not allowed:
-        raise HTTPException(
-            status_code=429,
-            detail="Too many new sessions from this network. Try again later.",
-            headers={"Retry-After": str(retry_after)},
-        )
-    token, user_id = create_anon_token()
-    return {"token": token, "anon": True, "daily_limit": settings.ANON_DAILY_LIMIT}
-
-
 # --- TOKEN REFRESH ---
 
 @router.post("/auth/refresh")

backend/routers/prompts.py

@@ -10,10 +10,10 @@ from fastapi import APIRouter, Depends, UploadFile, File, Form, Request, Backgro
 from fastapi.responses import StreamingResponse, JSONResponse
 from ..models.schemas import TrackRequest, EnhanceRequest, FeedbackRequest
 from ..core.config import settings
-from ..core.security import verify_jwt, verify_jwt_or_anon, is_anonymous
+from ..core.security import verify_jwt
 from ..core.ratelimit import enhance_limit, voice_limit
 from ..core import usage
-from ..core.database import MongoDB, in_memory_users, in_memory_saved_prompts, in_memory_prompt_logs
+from ..core.database import MongoDB, in_memory_users, in_memory_saved_prompts
 from ..services.analytics_service import AnalyticsService
 from ..services.memory_service import MemoryService
 from ..services.llm_service import get_groq_client, mark_groq_rate_limited
@@ -64,80 +64,9 @@ def _transcription_parts(result) -> tuple[str, str]:
     return str(text or "").strip(), code or "unknown"
 
 
-def _build_enhance_context(request: EnhanceRequest, user_id: str, fetch_saved_prompt_fn=None,
-                           use_memory: bool = True) -> dict:
+def _build_enhance_context(request: EnhanceRequest, user_id: str, fetch_saved_prompt_fn=None) -> dict:
     """The shared builder, reading attached saved prompts from this router's store."""
-    return _build_context(request, user_id, fetch_saved_prompt_fn or _fetch_saved_prompt,
-                          use_memory=use_memory)
-
-
-# ══════════════════════════════════════════════════════════════
-# ANONYMOUS TIER — an install that has not signed in
-# ══════════════════════════════════════════════════════════════
-# Quick rewrites of the draft alone: no chat context, no saved prompts, no
-# memory, no BYOK. Nothing is logged, so the count lives in core.usage's
-# per-process tally (it resets on restart, which errs toward the user).
-
-ANON_TOTAL_KEY = "__anon_total__"
-
-
-def _anon_request(request: EnhanceRequest) -> EnhanceRequest:
-    """The parts of a request the anonymous tier is allowed to use."""
-    return request.model_copy(update={
-        "mode": "quick",
-        "conversation_context": None,
-        "selected_prompt_ids": None,
-        "excluded_prompt_ids": None,
-        "tracking_enabled": False,
-        "byok_provider": None,
-        "byok_key": None,
-        "byok_model": None,
-    })
-
-
-def _anon_capacity_left() -> bool:
-    return usage.get(ANON_TOTAL_KEY) < settings.ANON_GLOBAL_DAILY_LIMIT
-
-
-def _record_anon_rewrite(user_id: str):
-    usage.record(user_id)
-    usage.record(ANON_TOTAL_KEY)
-
-
-def _limit_refusal(tier: str, used: int, limit: int, degraded: bool) -> dict:
-    """The body of a 429 for a user who cannot rewrite right now."""
-    if tier == "anon":
-        busy = not _anon_capacity_left()
-        return {
-            "error": "free_capacity_reached" if busy else "daily_limit_reached",
-            "detail": (
-                "Free rewrites without an account are busy right now. "
-                "Sign in with Google (it's free) to keep going."
-                if busy else
-                f"You've used today's {limit} free rewrites. Sign in with Google "
-                "(it's free) for more each day, plus the Deep and Creative styles "
-                "and a library for your saved prompts."
-            ),
-            "used": used, "limit": limit, "tier": tier, "degraded": False,
-            "sign_in_available": True, "byok_available": False,
-        }
-    degraded_note = (
-        " The prompt store is temporarily unreachable, so free usage is capped"
-        " lower than usual until it recovers."
-        if degraded else ""
-    )
-    return {
-        "error": "daily_limit_reached",
-        "detail": (
-            f"You've used all {limit} free enhancements for today. "
-            "Add your own free API key in the extension settings for "
-            "1,000 per day." + degraded_note
-            if tier != "byok" else
-            f"Daily limit of {limit} reached."
-        ),
-        "used": used, "limit": limit, "tier": tier, "degraded": degraded,
-        "byok_available": tier != "byok",
-    }
+    return _build_context(request, user_id, fetch_saved_prompt_fn or _fetch_saved_prompt)
 
 
 # ══════════════════════════════════════════════════════════════
@@ -161,8 +90,6 @@ def get_user_tier(user_id: str) -> str:
 
 def effective_tier(user_id: str, request) -> str:
     """A user supplying BYOK is not rationed against shared allowance."""
-    if is_anonymous(user_id):
-        return "anon"
     if getattr(request, "byok_key", None):
         return "byok"
     return get_user_tier(user_id)
@@ -201,9 +128,6 @@ def count_today(user_id: str) -> tuple:
 def check_daily_limit(user_id: str, tier: str) -> tuple:
     """Returns (allowed: bool, count: int, limit: int, degraded: bool)."""
     limit = settings.TIER_LIMITS.get(tier, settings.SHARED_KEY_DAILY_LIMIT)
-    if tier == "anon":
-        used = usage.get(user_id)
-        return (used < limit and _anon_capacity_left(), used, limit, False)
     count, degraded = count_today(user_id)
 
     if degraded and tier != "byok":
@@ -266,18 +190,36 @@ def enhance_prompt(
 ):
     """The core prompt engineering endpoint — intent-aware, mode-aware."""
     tier = effective_tier(user_id, request)
-    anon = tier == "anon"
-    if anon:
-        request = _anon_request(request)
     allowed, used, limit, degraded = check_daily_limit(user_id, tier)
+    degraded_note = (
+        " The prompt store is temporarily unreachable, so free usage is capped"
+        " lower than usual until it recovers."
+        if degraded else ""
+    )
     if not allowed:
-        return JSONResponse(status_code=429, content=_limit_refusal(tier, used, limit, degraded))
+        return JSONResponse(
+            status_code=429,
+            content={
+                "error": "daily_limit_reached",
+                "detail": (
+                    f"You've used all {limit} free enhancements for today. "
+                    "Add your own free API key in the extension settings for "
+                    "1,000 per day." + degraded_note
+                    if tier != "byok" else
+                    f"Daily limit of {limit} reached."
+                ),
+                "used": used,
+                "limit": limit,
+                "tier": tier,
+                "degraded": degraded,
+                "byok_available": tier != "byok",
+            },
+        )
 
     logger.info(f"\n🎯 /enhance — user={user_id[:8]}... mode={request.mode} tier={tier} ({used}/{limit})")
-    if not anon:   # an anonymous draft is not written anywhere, logs included
-        logger.info(f"   Prompt: \"{request.prompt[:80]}...\"")
+    logger.info(f"   Prompt: \"{request.prompt[:80]}...\"")
 
-    ctx = _build_enhance_context(request, user_id, _fetch_saved_prompt, use_memory=not anon)
+    ctx = _build_enhance_context(request, user_id, _fetch_saved_prompt)
 
     try:
         result = providers.chat(
@@ -305,18 +247,6 @@ def enhance_prompt(
 
     enhanced_prompt = result["content"]
     process_time = round(time.time() - ctx["start_time"], 2)
-
-    if anon:
-        _record_anon_rewrite(user_id)
-        return {
-            "original": request.prompt, "enhanced": enhanced_prompt, "log_id": None,
-            "latency": process_time, "mode": ctx["mode"], "model": result["model"],
-            "provider": result["provider"], "byok": False,
-            "truncated": result.get("truncated", False),
-            "usage_today": {"used": used + 1, "limit": limit, "tier": tier},
-            "context_used": _context_used(ctx, request),
-            "context_details": _context_details(ctx),
-        }
     
     # Log the enhancement; DO NOT memorize here. Memorization happens on /enhance/accept.
     # Always logged, whatever tracking_enabled says: this log is the user's
@@ -384,19 +314,25 @@ def enhance_prompt(
 def enhance_prompt_stream(request: EnhanceRequest, user_id: str = Depends(enhance_limit)):
     """Streaming enhancement — returns tokens as Server-Sent Events."""
     tier = effective_tier(user_id, request)
-    anon = tier == "anon"
-    if anon:
-        request = _anon_request(request)
     allowed, used, limit, degraded = check_daily_limit(user_id, tier)
 
     if not allowed:
         def refuse():
-            payload = _limit_refusal(tier, used, limit, degraded)
+            payload = {
+                "error": "daily_limit_reached",
+                "detail": (
+                    f"You've used all {limit} free enhancements for today. "
+                    "Add your own free API key in the extension settings for 1,000 per day."
+                    if tier != "byok" else f"Daily limit of {limit} reached."
+                ),
+                "used": used, "limit": limit, "degraded": degraded,
+                "byok_available": tier != "byok",
+            }
             yield f"data: {json.dumps(payload)}\n\n"
-            yield f"data: {json.dumps({'done': True, 'failed': True, **payload})}\n\n"
+            yield f"data: {json.dumps({'done': True, 'failed': True})}\n\n"
         return StreamingResponse(refuse(), media_type="text/event-stream")
 
-    ctx = _build_enhance_context(request, user_id, _fetch_saved_prompt, use_memory=not anon)
+    ctx = _build_enhance_context(request, user_id, _fetch_saved_prompt)
 
     def generate():
         enhanced_parts = []
@@ -434,12 +370,7 @@ def enhance_prompt_stream(request: EnhanceRequest, user_id: str = Depends(enhanc
         process_time = round(time.time() - ctx["start_time"], 2)
 
         log_id = None
-        counted = False
-        if enhanced_prompt.strip() and anon:
-            # Counted, never logged: see the anonymous tier above.
-            _record_anon_rewrite(user_id)
-            counted = True
-        elif enhanced_prompt.strip():
+        if enhanced_prompt.strip():
             max_similarity = ctx["similar_saved"][0]["score"] if ctx["similar_saved"] else 0.0
             # Always logged; see enhance_prompt for why tracking does not gate this.
             log_id = MemoryService.log_prompt(
@@ -479,7 +410,7 @@ def enhance_prompt_stream(request: EnhanceRequest, user_id: str = Depends(enhanc
             "model": meta.get("model"),
             "provider": meta.get("provider"),
             "byok": meta.get("byok", False),
-            "usage_today": {"used": used + (1 if (log_id or counted) else 0), "limit": limit, "tier": tier},
+            "usage_today": {"used": used + (1 if log_id else 0), "limit": limit, "tier": tier},
             "context_used": _context_used(ctx, request),
             "context_details": _context_details(ctx),
             "truncated": meta.get("truncated", False),
@@ -537,11 +468,8 @@ def enhance_history(user_id: str = Depends(verify_jwt)):
 
 
 @router.get("/enhance/usage")
-def enhance_usage(byok: bool = False, user_id: str = Depends(verify_jwt_or_anon)):
+def enhance_usage(byok: bool = False, user_id: str = Depends(verify_jwt)):
     """Returns today's enhancement count for the user."""
-    if is_anonymous(user_id):
-        return {"count": usage.get(user_id), "limit": settings.ANON_DAILY_LIMIT,
-                "tier": "anon", "degraded": False}
     count, degraded = count_today(user_id)
     tier = "byok" if byok else get_user_tier(user_id)
     limit = settings.TIER_LIMITS.get(tier, settings.SHARED_KEY_DAILY_LIMIT)

backend/services/prompt_builder.py

@@ -285,14 +285,8 @@ def _already_in_prompt(item: dict, prompt: str) -> bool:
     return float(item.get("score") or 0) >= _NEAR_DUPLICATE_SCORE
 
 
-def _build_enhance_context(request: EnhanceRequest, user_id: str, fetch_saved_prompt_fn=None,
-                           use_memory: bool = True) -> dict:
-    """
-    Shared context builder for every enhance route (text, stream, voice).
-
-    use_memory=False is the anonymous tier: no saved prompts, no past
-    patterns, no feedback summary, so nothing about any user is read.
-    """
+def _build_enhance_context(request: EnhanceRequest, user_id: str, fetch_saved_prompt_fn=None) -> dict:
+    """Shared context builder for every enhance route (text, stream, voice)."""
     start_time = time.time()
     mode = (request.mode or "deep").lower()
     if mode not in MODE_INSTRUCTIONS:
@@ -303,7 +297,7 @@ def _build_enhance_context(request: EnhanceRequest, user_id: str, fetch_saved_pr
 
     selected_context_parts = []
     selected_prompts = []
-    selected_ids = [str(pid) for pid in (request.selected_prompt_ids or [])] if use_memory else []
+    selected_ids = [str(pid) for pid in (request.selected_prompt_ids or [])]
     for pid in selected_ids:
         doc = fetch_saved_prompt_fn(pid, user_id) if fetch_saved_prompt_fn else None
         if doc:
@@ -322,7 +316,7 @@ def _build_enhance_context(request: EnhanceRequest, user_id: str, fetch_saved_pr
             exclude_ids=selected_ids + excluded_ids,
         )
         if not _already_in_prompt(item, request.prompt)
-    ] if use_memory else []
+    ]
     similarity_context_parts = []
     for item in similar_saved:
         label = item.get("title") or "Saved Prompt"
@@ -335,14 +329,14 @@ def _build_enhance_context(request: EnhanceRequest, user_id: str, fetch_saved_pr
         user_id=user_id,
         query_text=request.prompt,
         limit=3,
-    ) if use_memory else []
+    )
     for pm in passive_matches:
         if pm["original"] != pm["refined"]:
             passive_context_parts.append(
                 f'[Past pattern] User asked: "{pm["original"]}" → Was refined to: "{pm["refined"]}"'
             )
 
-    feedback_summary = MemoryService.get_user_feedback_summary(user_id) if use_memory else ""
+    feedback_summary = MemoryService.get_user_feedback_summary(user_id)
 
     system_parts = [
         SYSTEM_PROMPT_BASE,