@ngocsangairvds/vsaf 3.2.15 → 4.0.0

package/tools/vds-scripts/memory_orchestrator/src/vds_memory_orchestrator/service/api/ai_memory_api.py

@@ -1,1172 +0,0 @@
-"""
-VDS AI Memory API Endpoints
-Advanced AI-powered Memory and Session management API endpoints.
-"""
-
-import logging
-from datetime import UTC, datetime
-
-from fastapi import APIRouter, Depends, Header, HTTPException, Query, Response, status
-
-from vds_memory_orchestrator.service.api.status_mapping import resolve_status_response
-from vds_memory_orchestrator.service.core.ai_memory_exceptions import (
-    MemoryRevisionConflictError,
-    NotFoundError,
-)
-from vds_memory_orchestrator.service.core.auth import get_current_user
-from vds_memory_orchestrator.service.core.config import get_config
-from vds_memory_orchestrator.service.database.redis_manager import RedisService, get_redis
-from vds_memory_orchestrator.service.models.ai_memory_models import (
-    Analytics,
-    AnalyticsRequest,
-    ConsolidationResponse,
-    HealthResponse,
-    MemoryBatchCreateRequest,
-    MemoryBatchDeleteRequest,
-    MemoryBatchUpdateRequest,
-    MemoryCreateRequest,
-    MemoryDeleteRequest,
-    MemoryExportCreateRequest,
-    MemoryExportStatusResponse,
-    MemoryFeedbackRequest,
-    MemorySearchRequest,
-    MemorySearchResponse,
-    MemoryUpdateRequest,
-    SessionBackupRequest,
-    SessionBackupResponse,
-    SessionBackupSummary,
-    SessionBehaviorAnalytics,
-    SessionConsolidationRequest,
-    SessionContextRequest,
-    SessionContextResponse,
-    SessionCreateRequest,
-    SessionCreateResponse,
-    SessionPerformanceMetrics,
-    SessionPerformanceSummary,
-    SessionRestoreRequest,
-    SessionRestoreResponse,
-    SessionShareListEntry,
-    SessionShareRequest,
-    SessionShareResponse,
-    SessionTemplateInstantiateRequest,
-    SessionTemplateMetadata,
-    SessionUpdateRequest,
-    TeamInsightRequest,
-    TeamInsightResponse,
-    TeamMemoryShare,
-    TeamMemorySynthesisRequest,
-    TeamMemorySynthesisResponse,
-    TopicClusteringRequest,
-    TopicClusteringResponse,
-)
-from vds_memory_orchestrator.service.services.ai_memory_service import (
-    VDSAIMemoryService,
-    get_ai_memory_service,
-)
-from vds_memory_orchestrator.service.services.health_check import (
-    HealthCheckService,
-    get_health_checker,
-)
-
-logger = logging.getLogger(__name__)
-config = get_config()
-
-# Create router
-router = APIRouter(prefix="/api/v1", tags=["ai_memory"])
-
-
-# Dependency for rate limiting (optional future implementation)
-# Rate limiting is configured in config but not enforced at API level yet
-# Individual services handle their own rate limiting logic
-
-
-# Health endpoints
-@router.get("/health", response_model=HealthResponse, tags=["health"])
-async def health_check():
-    """Legacy health check for backwards compatibility."""
-    try:
-        service = await get_ai_memory_service()
-        raw = await service.health_check()
-
-        return HealthResponse(
-            status=raw.get("status", {}).get("overall", "unknown"),
-            service_name=config.service.name,
-            version=config.service.version,
-            timestamp=datetime.now(UTC),
-            components=raw.get("components", {}),
-            uptime_seconds=raw.get("uptime_seconds"),
-            metrics=raw.get("metrics", {}),
-        )
-    except Exception as e:
-        logger.exception("Health check failed: %s", e)
-        raise HTTPException(
-            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-            detail="Service temporarily unavailable",
-        ) from e
-
-
-@router.get("/health/full", tags=["health"])
-async def full_health_check(
-    health_checker: HealthCheckService = Depends(get_health_checker),
-):
-    """Detailed health report including per-layer diagnostics."""
-    try:
-        return await health_checker.check_all_layers()
-    except Exception as e:
-        logger.exception("Full health check failed: %s", e)
-        raise HTTPException(
-            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-            detail="Service temporarily unavailable",
-        ) from e
-
-
-# Session Management Endpoints
-@router.post("/sessions", response_model=SessionCreateResponse, tags=["sessions"])
-async def create_session(
-    request: SessionCreateRequest,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Create a new session."""
-    return await service.create_session(request)
-
-
-@router.get(
-    "/sessions/templates",
-    response_model=list[SessionTemplateMetadata],
-    tags=["sessions"],
-)
-async def list_session_templates(
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """List available reusable session templates."""
-    return service.list_session_templates()
-
-
-@router.get(
-    "/sessions/templates/{template_id}",
-    response_model=SessionTemplateMetadata,
-    tags=["sessions"],
-)
-async def get_session_template(
-    template_id: str, service: VDSAIMemoryService = Depends(get_ai_memory_service)
-):
-    """Fetch template metadata by identifier."""
-    try:
-        return service.get_session_template(template_id)
-    except ValueError as exc:  # template not found
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=str(exc),
-        ) from exc
-
-
-@router.post(
-    "/sessions/templates/{template_id}/instantiate",
-    response_model=SessionCreateResponse,
-    tags=["sessions"],
-)
-async def instantiate_session_template(
-    template_id: str,
-    request: SessionTemplateInstantiateRequest,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Create a new session using a template preset."""
-    try:
-        return await service.instantiate_session_template(template_id, request)
-    except (NotFoundError, ValueError) as exc:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=str(exc),
-        ) from exc
-
-
-@router.get("/sessions/{session_id}", tags=["sessions"])
-async def get_session(
-    session_id: str, service: VDSAIMemoryService = Depends(get_ai_memory_service)
-):
-    """Get session by ID."""
-    session = await service.get_session(session_id)
-    if not session:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Session not found: {session_id}",
-        )
-    return session
-
-
-@router.put("/sessions/{session_id}", tags=["sessions"])
-async def update_session(
-    session_id: str,
-    request: SessionUpdateRequest,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Update session data."""
-    # Ensure session_id matches request
-    if request.session_id != session_id:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Session ID in path and request must match",
-        )
-
-    success = await service.update_session(request)
-    if not success:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to update session",
-        )
-
-    return {"message": "Session updated successfully"}
-
-
-@router.delete("/sessions/{session_id}", tags=["sessions"])
-async def delete_session(
-    session_id: str, service: VDSAIMemoryService = Depends(get_ai_memory_service)
-):
-    """Delete a session."""
-    success = await service.delete_session(session_id)
-    if not success:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to delete session",
-        )
-
-    return {"message": "Session deleted successfully"}
-
-
-@router.get("/sessions/user/{user_id}", response_model=list[str], tags=["sessions"])
-async def get_user_sessions(
-    user_id: str, service: VDSAIMemoryService = Depends(get_ai_memory_service)
-):
-    """Get all sessions for a user."""
-    return await service.get_user_sessions(user_id)
-
-
-@router.post("/sessions/cleanup", tags=["sessions"])
-async def cleanup_expired_sessions(
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Clean up expired sessions."""
-    cleaned_count = await service.cleanup_expired_sessions()
-    return {"message": f"Cleaned up {cleaned_count} expired sessions"}
-
-
-@router.get(
-    "/sessions/{session_id}/analytics/details",
-    response_model=SessionBehaviorAnalytics,
-    tags=["sessions"],
-)
-async def get_session_behavior_metrics_endpoint(
-    session_id: str,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Get detailed behavior analytics for a specific session."""
-    try:
-        return await service.get_session_behavior_metrics(session_id)
-    except NotFoundError as exc:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=str(exc),
-        ) from exc
-
-
-@router.post(
-    "/sessions/backup",
-    response_model=SessionBackupResponse,
-    tags=["sessions"],
-)
-async def backup_session_endpoint(
-    request: SessionBackupRequest,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Create a point-in-time backup for a session."""
-    try:
-        return await service.backup_session(request)
-    except NotFoundError as exc:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
-
-
-@router.get(
-    "/sessions/{session_id}/backups",
-    response_model=list[SessionBackupSummary],
-    tags=["sessions"],
-)
-async def list_session_backups_endpoint(
-    session_id: str,
-    limit: int = 10,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """List stored backups for a session."""
-    return await service.list_session_backups(session_id, limit)
-
-
-@router.post(
-    "/sessions/restore",
-    response_model=SessionRestoreResponse,
-    tags=["sessions"],
-)
-async def restore_session_endpoint(
-    request: SessionRestoreRequest,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Restore session state from a backup snapshot."""
-    try:
-        return await service.restore_session_from_backup(request)
-    except NotFoundError as exc:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
-
-
-@router.post(
-    "/sessions/{session_id}/share",
-    response_model=SessionShareResponse,
-    tags=["sessions"],
-)
-async def share_session_endpoint(
-    session_id: str,
-    request: SessionShareRequest,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Share a session with a user or team."""
-    payload = request.model_copy(update={"session_id": session_id})
-    return await service.share_session(session_id, payload)
-
-
-@router.delete(
-    "/sessions/{session_id}/share/{share_id}",
-    tags=["sessions"],
-)
-async def revoke_session_share_endpoint(
-    session_id: str,
-    share_id: str,
-    revoked_by: str,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Revoke a session share."""
-    success = await service.revoke_session_share(session_id, share_id, revoked_by)
-    if not success:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Session share not found",
-        )
-    return {"message": "Session share revoked"}
-
-
-@router.get(
-    "/sessions/{session_id}/shares",
-    response_model=list[SessionShareResponse],
-    tags=["sessions"],
-)
-async def list_session_shares_endpoint(
-    session_id: str,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """List all shares created for a session."""
-    return await service.list_session_shares(session_id)
-
-
-@router.get(
-    "/sessions/shared",
-    response_model=list[SessionShareListEntry],
-    tags=["sessions"],
-)
-async def list_shared_sessions_endpoint(
-    user_id: str,
-    team_id: str | None = None,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """List sessions shared with a user and optional teams."""
-    team_ids = [team_id] if team_id else []
-    return await service.list_shared_sessions(user_id, team_ids)
-
-
-@router.get(
-    "/sessions/{session_id}/performance",
-    response_model=SessionPerformanceMetrics,
-    tags=["sessions"],
-)
-async def get_session_performance(
-    session_id: str,
-    timeframe_hours: int = 24,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Get performance metrics for a specific session."""
-    return await service.get_session_performance_metrics(session_id, timeframe_hours)
-
-
-@router.get(
-    "/sessions/performance",
-    response_model=SessionPerformanceSummary,
-    tags=["sessions"],
-)
-async def get_sessions_performance_summary(
-    timeframe_hours: int = 24,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Get aggregate session performance metrics."""
-    return await service.get_session_performance_summary(timeframe_hours)
-
-
-# Memory Management Endpoints
-@router.get("/memories", tags=["memories"])
-async def list_memories(
-    current_user: dict = Depends(get_current_user),
-):
-    """List endpoint — requires authentication. Use POST /memories/search for full search."""
-    return {
-        "memories": [],
-        "user_id": current_user.get("id"),
-        "message": "Use POST /memories/search for full search",
-    }
-
-
-@router.post("/memories", tags=["memories"])
-async def create_memory(
-    request: MemoryCreateRequest,
-    response: Response,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Create a new memory.
-
-    Behavior is gated by ``mem0.store_async_mode`` feature flag (VAMI-017 Phase B):
-
-    - **flag OFF** (default): synchronous full-stack create. Returns 200/201 with
-      ``{memory_id, mem0_status, message}`` after mem0 add completes. Back-compat.
-    - **flag ON**: memory row + embedding persisted inline; mem0 add + fact
-      extraction queued to Celery (T-A3 in memory_crud_service.py). Returns
-      **202 Accepted** with ``{memory_id, status: "queued", poll_url}``. Clients
-      poll ``GET /memories/{id}/status`` (T-A4) for terminal state. T-A5 client
-      helper ``wait_for_mem0_id()`` wraps the poll loop.
-    """
-    from vds_memory_orchestrator.service.core.input_validation import TextInputValidation
-
-    try:
-        TextInputValidation.validate_no_xss(request.content)
-    except ValueError as e:
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) from e
-
-    # Resolve the async-mode flag. Fall back to False on any config access
-    # error — never break the sync path behind a config lookup.
-    async_mode = False
-    try:
-        async_mode = bool(getattr(get_config().mem0, "store_async_mode", False))
-    except Exception:  # pragma: no cover - defensive
-        async_mode = False
-
-    memory_id = await service.create_memory(request)
-
-    if async_mode:
-        # VAMI-017 Phase B T-A2 — 202 Accepted. The inline mem0 add has been
-        # skipped by memory_crud_service (T-A3 elif branch); Celery worker
-        # will resolve mem0_id in the background.
-        response.status_code = status.HTTP_202_ACCEPTED
-        return {
-            "memory_id": memory_id,
-            "status": "queued",
-            "poll_url": f"/api/v1/memories/{memory_id}/status",
-            "message": "Memory queued for async processing",
-        }
-
-    # Synchronous (back-compat) response path
-    mem0_status = None
-    try:
-        memory = await service.get_memory(memory_id)
-        if isinstance(memory, dict):
-            mem0_status = (memory.get("metadata") or {}).get("mem0_status")
-        else:
-            meta = getattr(memory, "metadata", None)
-            if isinstance(meta, dict):
-                mem0_status = meta.get("mem0_status")
-    except Exception:
-        mem0_status = None
-    return {
-        "memory_id": memory_id,
-        "mem0_status": mem0_status,
-        "message": "Memory created successfully",
-    }
-
-
-@router.get("/memories/{memory_id}/status", tags=["memories"])
-async def get_memory_status(
-    memory_id: str,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Get the processing status of a memory (VAMI-017 Phase B T-A4, VAMI-018 T-F1-1).
-
-    Returns ``{status, mem0_id?, error?}`` describing the mem0 async
-    processing state for a given memory_id. Useful both in sync-mode (to
-    check mem0 backfill progress) and in async-mode (to poll after a 202
-    Accepted).
-
-    Status mapping from ``metadata.mem0_status`` (aligned to canonical writer
-    vocabulary — VAMI-018 ADR-17):
-
-    - ``"synced"`` / ``"success"`` or mem0_id present -> ``"complete"``
-    - ``"stalled"`` -> ``"failed"`` with ``error`` from ``mem0_stalled_reason``
-    - ``"failed"`` / ``"error"`` -> ``"failed"`` with ``error`` from ``mem0_reason``
-    - ``"pending"`` -> ``"queued"``
-    - ``"processing"`` -> ``"processing"``
-    - any other non-None value -> ``"failed"`` with ``error = f"unknown mem0_status=<value>"``
-      (explicit surface for enum drift — VAMI-018 ADR-18; previously fell
-      through to silently return ``"processing"`` forever)
-    - ``None`` without mem0_id -> ``"complete"`` (sync-mode completion without
-      mem0 metadata)
-    - missing record -> HTTP 404
-    """
-    memory = await service.get_memory(memory_id)
-    if not memory:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Memory not found")
-    return resolve_status_response(memory, memory_id)
-
-
-@router.post("/memories/batch", tags=["memories"])
-async def batch_create_memories(
-    request: MemoryBatchCreateRequest,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Batch create memories (max 100 per request)."""
-    return await service.batch_create_memories(request)
-
-
-@router.get("/memories/{memory_id}", tags=["memories"])
-async def get_memory(
-    memory_id: str,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Fetch a memory with transparency fields (storage tier, relations)."""
-    memory = await service.get_memory(memory_id)
-    if not memory:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Memory not found")
-    return memory
-
-
-@router.patch("/memories/{memory_id}", tags=["memories"])
-async def update_memory(
-    memory_id: str,
-    request: MemoryUpdateRequest,
-    if_match: str | None = Header(default=None, alias="If-Match"),
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Update a memory (Postgres + Mem0 parity)."""
-    expected_from_header = _parse_if_match_version(if_match)
-    expected_from_body = request.expected_current_version_number
-    if (
-        expected_from_header is not None
-        and expected_from_body is not None
-        and expected_from_header != expected_from_body
-    ):
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=(
-                "If-Match revision does not match body precondition "
-                "(expected_current_version_number)."
-            ),
-        )
-
-    expected_revision = (
-        expected_from_body if expected_from_body is not None else expected_from_header
-    )
-    payload = request.model_copy(
-        update={
-            "memory_id": memory_id,
-            "expected_current_version_number": expected_revision,
-        }
-    )
-    try:
-        memory = await service.update_memory(payload)
-        return memory
-    except MemoryRevisionConflictError as exc:
-        raise HTTPException(
-            status_code=status.HTTP_409_CONFLICT,
-            detail={
-                "error": "revision_conflict",
-                "memory_id": exc.memory_id,
-                "expected_revision": exc.expected_revision,
-                "actual_revision": exc.actual_revision,
-            },
-        ) from exc
-
-
-def _parse_if_match_version(if_match: str | None) -> int | None:
-    """Parse If-Match header into integer memory revision."""
-    if if_match is None:
-        return None
-    token = if_match.strip()
-    if not token:
-        return None
-    if token.startswith("W/"):
-        token = token[2:].strip()
-    if token.startswith('"') and token.endswith('"') and len(token) >= 2:
-        token = token[1:-1]
-    try:
-        parsed = int(token)
-    except ValueError as exc:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="If-Match must be an integer memory revision.",
-        ) from exc
-    if parsed < 1:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="If-Match memory revision must be >= 1.",
-        )
-    return parsed
-
-
-@router.delete("/memories/{memory_id}", tags=["memories"])
-async def delete_memory(
-    memory_id: str,
-    hard_delete: bool = False,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Delete a memory from all backends (soft by default)."""
-    success = await service.delete_memory(
-        MemoryDeleteRequest(memory_id=memory_id, hard_delete=hard_delete)
-    )
-    if not success:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Memory not found",
-        )
-    return {"message": "Memory deleted"}
-
-
-@router.post("/memories/batch/update", tags=["memories"])
-async def batch_update_memories(
-    request: MemoryBatchUpdateRequest,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Batch update memories; forwards filters to Mem0 where supported."""
-    return await service.batch_update_memories(request)
-
-
-@router.post("/memories/batch/delete", tags=["memories"])
-async def batch_delete_memories(
-    request: MemoryBatchDeleteRequest,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Batch delete memories by IDs or filters."""
-    deleted = await service.batch_delete_memories(request)
-    return {"deleted": deleted}
-
-
-@router.post("/memories/delete_all", tags=["memories"])
-async def delete_memories_by_filter(
-    request: MemoryBatchDeleteRequest,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Delete all memories matching filters across tiers."""
-    deleted = await service.delete_memories_by_filter(request)
-    return {"deleted": deleted}
-
-
-@router.post("/memories/search", response_model=MemorySearchResponse, tags=["memories"])
-async def search_memories(
-    request: MemorySearchRequest,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Search memories."""
-    from vds_memory_orchestrator.service.core.input_validation import validate_no_sql_injection
-
-    try:
-        validate_no_sql_injection(request.query)
-    except ValueError as e:
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)) from e
-    return await service.search_memories(request)
-
-
-@router.post(
-    "/memories/topics/cluster",
-    response_model=TopicClusteringResponse,
-    tags=["memories"],
-)
-async def cluster_memory_topics(
-    request: TopicClusteringRequest,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Cluster memories into topic groups."""
-    return await service.cluster_memory_topics(request)
-
-
-@router.post("/memories/export", response_model=MemoryExportStatusResponse, tags=["memories"])
-async def create_memory_export(
-    request: MemoryExportCreateRequest,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Create a Mem0 export job."""
-    return await service.create_memory_export(request)
-
-
-@router.get(
-    "/memories/export/{export_id}",
-    response_model=MemoryExportStatusResponse,
-    tags=["memories"],
-)
-async def get_memory_export_status(
-    export_id: str,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Fetch status for a Mem0 export job."""
-    return await service.get_memory_export(export_id)
-
-
-@router.get("/memories/{memory_id}/history", tags=["memories"])
-async def get_memory_history(
-    memory_id: str,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Retrieve Mem0 history for a memory."""
-    return await service.get_memory_history(memory_id)
-
-
-@router.post("/memories/{memory_id}/feedback", tags=["memories"])
-async def submit_memory_feedback(
-    memory_id: str,
-    request: MemoryFeedbackRequest,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Submit feedback for a memory to Mem0."""
-    payload = request.model_copy(update={"memory_id": memory_id})
-    return await service.submit_memory_feedback(payload)
-
-
-# Session Context Endpoints
-@router.get(
-    "/sessions/context/{session_id}",
-    response_model=SessionContextResponse,
-    tags=["sessions"],
-)
-async def get_session_context(
-    session_id: str,
-    include_memories: bool = True,
-    include_operations: bool = True,
-    include_analytics: bool = False,
-    memory_limit: int = 20,
-    operation_limit: int = 50,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Get comprehensive session context."""
-    request = SessionContextRequest(
-        session_id=session_id,
-        include_memories=include_memories,
-        include_operations=include_operations,
-        include_analytics=include_analytics,
-        memory_limit=memory_limit,
-        operation_limit=operation_limit,
-    )
-    try:
-        return await service.get_session_context(request)
-    except ValueError as exc:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=str(exc),
-        ) from exc
-
-
-@router.post("/sessions/consolidate", response_model=ConsolidationResponse, tags=["sessions"])
-async def consolidate_session(
-    request: SessionConsolidationRequest,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Consolidate session memories."""
-    return await service.consolidate_session(request)
-
-
-# Analytics Endpoints
-@router.get("/analytics/user/{user_id}", response_model=Analytics, tags=["analytics"])
-async def get_user_analytics(
-    user_id: str,
-    timeframe_hours: int = 24,
-    include_sessions: bool = True,
-    include_memories: bool = True,
-    include_operations: bool = True,
-    include_patterns: bool = True,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Get analytics for a specific user."""
-    request = AnalyticsRequest(
-        user_id=user_id,
-        timeframe_hours=timeframe_hours,
-        include_sessions=include_sessions,
-        include_memories=include_memories,
-        include_operations=include_operations,
-        include_patterns=include_patterns,
-    )
-    return await service.get_analytics(request)
-
-
-@router.get("/analytics/global", response_model=Analytics, tags=["analytics"])
-async def get_global_analytics(
-    timeframe_hours: int = 24,
-    include_sessions: bool = True,
-    include_memories: bool = True,
-    include_operations: bool = True,
-    include_patterns: bool = True,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Get global analytics."""
-    request = AnalyticsRequest(
-        user_id=None,
-        timeframe_hours=timeframe_hours,
-        include_sessions=include_sessions,
-        include_memories=include_memories,
-        include_operations=include_operations,
-        include_patterns=include_patterns,
-    )
-    return await service.get_analytics(request)
-
-
-# Utility Endpoints
-@router.post("/cache/warmup/{user_id}", tags=["utility"])
-async def warmup_cache(
-    user_id: str,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-    redis: RedisService = Depends(get_redis),
-):
-    """Warm up cache for a user."""
-    warmed_items = await redis.warmup_cache(user_id)
-    return {
-        "message": f"Cache warmed up for user {user_id}",
-        "warmed_items": warmed_items,
-    }
-
-
-@router.post("/cache/invalidate/{session_id}", tags=["utility"])
-async def invalidate_cache(session_id: str, redis: RedisService = Depends(get_redis)):
-    """Invalidate cache for a session."""
-    invalidated = await redis.cross_invalidate(session_id)
-    return {
-        "message": f"Cache invalidated for session {session_id}",
-        "success": invalidated,
-    }
-
-
-# Configuration Endpoints
-@router.get("/config", tags=["configuration"])
-async def get_configuration():
-    """Get service configuration."""
-    config = get_config()
-    return {
-        "service": {
-            "name": config.service.name,
-            "version": config.service.version,
-            "environment": "development" if config.is_development else "production",
-            "debug": config.service.debug,
-        },
-        "features": {
-            "mem0_pro": config.mem0.api_key != "",
-            "mcp_server": config.mcp.enable_mcp_server,
-            "analytics": config.service.enable_metrics,
-        },
-        "rate_limiting": {
-            "enabled": config.service.enable_rate_limiting,
-            "default_limit": config.service.default_rate_limit,
-            "memory_limit": config.service.memory_rate_limit,
-            "session_limit": config.service.session_rate_limit,
-        },
-        "redis": {
-            "databases": {
-                "memory_cache": config.database.redis_memory_cache_db,
-                "session_store": config.database.redis_session_store_db,
-                "analytics": config.database.redis_analytics_db,
-            },
-            "connection_pool": {
-                "max_connections": config.database.max_connections,
-                "socket_timeout": config.database.socket_timeout,
-            },
-        },
-    }
-
-
-# Statistics Endpoints
-@router.get("/stats", tags=["statistics"])
-async def get_statistics(
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-    redis: RedisService = Depends(get_redis),
-    include_internal: bool = Query(
-        default=False,
-        description="Include internal healthcheck/test users in statistics",
-    ),
-):
-    """Get service statistics from real Redis data."""
-    from vds_memory_orchestrator.service.core.config import REDIS_ANALYTICS_DB
-    from vds_memory_orchestrator.service.database.redis_manager import redis_manager
-
-    # Get Redis health
-    redis_health = await redis.health_check()
-
-    # Get real uptime from service
-    uptime_seconds = 0
-    if service._startup_time:
-        uptime_seconds = int((datetime.now(UTC) - service._startup_time).total_seconds())
-
-    # Get real request metrics from Redis
-    total_requests = 0
-    try:
-        async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-            resp_count = await conn.get("metrics:resp:count")
-            total_requests = int(resp_count) if resp_count else 0
-    except Exception:
-        pass
-
-    # Calculate requests per minute
-    requests_per_minute = 0
-    if uptime_seconds > 0:
-        requests_per_minute = round((total_requests / uptime_seconds) * 60, 2)
-
-    # Get real cache metrics from Redis
-    cache_hit_rate = 0.0
-    try:
-        async with redis_manager.get_redis(REDIS_ANALYTICS_DB) as conn:
-            hits = await conn.get("metrics:cache:hits")
-            misses = await conn.get("metrics:cache:misses")
-            if hits or misses:
-                hits_count = int(hits) if hits else 0
-                misses_count = int(misses) if misses else 0
-                total = hits_count + misses_count
-                cache_hit_rate = round(hits_count / total, 3) if total > 0 else 0.0
-    except Exception:
-        pass
-
-    # Count total Redis keys and memory usage from health check
-    total_keys = 0
-    memory_usage = "0B"
-    for _db_name, db_info in redis_health.get("databases", {}).items():
-        if "used_memory" in db_info:
-            memory_usage = db_info["used_memory"]
-
-    # Count active sessions via Redis user index (respects include_internal filter)
-    active_sessions = await service.count_active_sessions(include_internal=include_internal)
-
-    # Count total memories from Postgres (respects include_internal filter)
-    total_memories = await service.count_memories(include_internal=include_internal)
-
-    # TSK-4.18: reconciliation_summary — last_reconciliation_at, permanently_stalled_count,
-    # recovered_last_24h (rows where mem0_reconciled_at is within the last 24 hours).
-    reconciliation_summary: dict = {
-        "last_reconciliation_at": None,
-        "permanently_stalled_count": 0,
-        "recovered_last_24h": 0,
-    }
-    try:
-        from sqlalchemy import text as _text
-
-        from vds_memory_orchestrator.service.database.postgres_manager import (
-            database_service as _db_svc,
-        )
-
-        if _db_svc.postgres._initialized:
-            async with _db_svc.postgres.engine.begin() as conn:
-                rec_result = await conn.execute(
-                    _text("""
-                    SELECT
-                        MAX(metadata->>'mem0_reconciled_at') AS last_reconciliation_at,
-                        COUNT(*) FILTER (
-                            WHERE (metadata->>'mem0_permanently_stalled')::boolean IS TRUE
-                        ) AS permanently_stalled_count,
-                        COUNT(*) FILTER (
-                            WHERE metadata->>'mem0_reconciled_at' IS NOT NULL
-                              AND (metadata->>'mem0_reconciled_at')::timestamptz
-                                  > NOW() - INTERVAL '24 hours'
-                        ) AS recovered_last_24h
-                    FROM memories
-                """)
-                )
-                rec_row = rec_result.mappings().one()
-                reconciliation_summary = {
-                    "last_reconciliation_at": rec_row["last_reconciliation_at"],
-                    "permanently_stalled_count": rec_row["permanently_stalled_count"] or 0,
-                    "recovered_last_24h": rec_row["recovered_last_24h"] or 0,
-                }
-    except Exception:
-        pass  # fail-open: return zero-state summary if Postgres unavailable
-
-    return {
-        "service": {
-            "uptime_seconds": uptime_seconds,
-            "total_requests": total_requests,
-            "requests_per_minute": requests_per_minute,
-        },
-        "redis": redis_health,
-        "background_tasks": len(service._background_tasks),
-        "cache": {
-            "hit_rate": cache_hit_rate,
-            "total_keys": total_keys,
-            "memory_usage": memory_usage,
-        },
-        "sessions": {"active": active_sessions},
-        "memories": {"total": total_memories},
-        "reconciliation_summary": reconciliation_summary,
-    }
-
-
-# =============================================================================
-# TEAM COLLABORATION API ENDPOINTS
-# =============================================================================
-
-
-@router.post("/team/memory/share", response_model=dict, tags=["team"])
-async def share_memory_with_team(
-    request: TeamMemoryShare,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Share a memory with a team."""
-    try:
-        success = await service.share_memory_with_team(request)
-        if success:
-            return {
-                "success": True,
-                "message": f"Memory {request.memory_id} successfully shared with team {request.team_id}",
-                "shared_at": request.shared_at.isoformat(),
-                "access_level": request.access_level.value,
-            }
-        else:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail="Failed to share memory with team",
-            )
-    except Exception as e:
-        logger.exception("Error sharing memory with team: %s", e)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to share memory: {str(e)}",
-        ) from e
-
-
-@router.get("/team/{team_id}/memories", response_model=dict, tags=["team"])
-async def get_team_memories(
-    team_id: str,
-    user_id: str,
-    limit: int = 50,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Get shared memories for a team."""
-    try:
-        memories = await service.get_team_memories(team_id, user_id, limit)
-        return {
-            "team_id": team_id,
-            "memories": [
-                {
-                    "memory_id": mem.memory_id,
-                    "content": mem.content[:200] + "..." if len(mem.content) > 200 else mem.content,
-                    "category": mem.category.value
-                    if hasattr(mem.category, "value")
-                    else str(mem.category),
-                    "importance": mem.importance.value
-                    if hasattr(mem.importance, "value")
-                    else str(mem.importance),
-                    "user_id": mem.user_id,
-                    "created_at": mem.created_at.isoformat() if mem.created_at else None,
-                    "access_count": getattr(mem, "access_count", 0),
-                }
-                for mem in memories
-            ],
-            "total_count": len(memories),
-            "limit": limit,
-        }
-    except Exception as e:
-        logger.exception("Error getting team memories: %s", e)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to retrieve team memories: {str(e)}",
-        ) from e
-
-
-@router.post("/team/{team_id}/insights", response_model=TeamInsightResponse, tags=["team"])
-async def generate_team_insights(
-    team_id: str,
-    request: TeamInsightRequest,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Generate AI-powered insights for a team."""
-    try:
-        # Ensure team_id matches path parameter
-        request.team_id = team_id
-
-        insights = await service.generate_team_insights(request)
-        return insights
-    except Exception as e:
-        logger.exception("Error generating team insights: %s", e)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to generate team insights: {str(e)}",
-        ) from e
-
-
-@router.post(
-    "/team/{team_id}/synthesis",
-    response_model=TeamMemorySynthesisResponse,
-    tags=["team"],
-)
-async def synthesize_team_memories(
-    team_id: str,
-    request: TeamMemorySynthesisRequest,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Synthesize team memories into comprehensive insights."""
-    try:
-        # Ensure team_id matches path parameter
-        request.team_id = team_id
-
-        synthesis = await service.synthesize_team_memories(request)
-        return synthesis
-    except Exception as e:
-        logger.exception("Error synthesizing team memories: %s", e)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to synthesize team memories: {str(e)}",
-        ) from e
-
-
-@router.get("/team/{team_id}/analytics", response_model=dict, tags=["team"])
-async def get_team_analytics(
-    team_id: str,
-    user_id: str,
-    service: VDSAIMemoryService = Depends(get_ai_memory_service),
-):
-    """Get basic analytics for a team."""
-    try:
-        # Get team memories
-        memories = await service.get_team_memories(team_id, user_id, limit=200)
-
-        if not memories:
-            return {
-                "team_id": team_id,
-                "total_memories": 0,
-                "active_contributors": 0,
-                "categories": {},
-                "recent_activity": 0,
-                "message": "No team memories found",
-            }
-
-        # Calculate basic analytics
-        categories = {}
-        contributors = set()
-        recent_count = 0
-
-        for mem in memories:
-            # Category distribution
-            cat = mem.category.value if hasattr(mem.category, "value") else str(mem.category)
-            categories[cat] = categories.get(cat, 0) + 1
-
-            # Contributors
-            if mem.user_id:
-                contributors.add(mem.user_id)
-
-            # Recent activity (last 7 days)
-            if mem.created_at and (datetime.now(UTC) - mem.created_at).days < 7:
-                recent_count += 1
-
-        return {
-            "team_id": team_id,
-            "total_memories": len(memories),
-            "active_contributors": len(contributors),
-            "categories": categories,
-            "recent_activity": recent_count,
-            "top_category": max(categories.items(), key=lambda x: x[1])[0] if categories else None,
-            "generated_at": datetime.now(UTC).isoformat(),
-        }
-    except Exception as e:
-        logger.exception("Error getting team analytics: %s", e)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to retrieve team analytics: {str(e)}",
-        ) from e