feat: add auto-discard and restore for short conversations #3464
+386
−31
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Implement automatic discarding of conversations shorter than 30 seconds with ability to restore them. This helps reduce clutter from accidental or test recordings while preserving user control. Backend changes: - Add duration, discarded_reason, discarded_at, restored_at fields to Conversation model - Add 'discarded' status to ConversationStatus enum - Implement auto-discard logic for conversations < 30 seconds - Add /discard and /restore API endpoints - Add Firestore composite index for efficient querying - Add test endpoints for validation Frontend changes: - Update conversation data model with discard fields - Add discardConversation() and restoreConversation() API functions - Implement restoreConversationLocally() in provider - Add smart swipe actions (green restore for discarded, red delete for active) - Add "Show Discarded" toggle switch on conversations page - Update conversation cards to show "Auto-discarded" tag Tested: - Backend endpoints fully tested with curl - Auto-discard logic verified for < 30s conversations - Restore functionality working correctly - Statistics tracking accurate 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
![gemini-code-assist[bot]](https://avatars.githubusercontent.com/in/956858?s=60&v=4){kind=small}
Contributor
There was a problem hiding this comment.
Code Review
This pull request introduces a feature to automatically discard short conversations and allow users to restore them. The changes span both the backend and frontend, adding new data model fields, API endpoints, and UI components to support this functionality. My review has identified a few critical issues in the backend implementation that need to be addressed. These include the presence of unauthenticated test endpoints that can modify data, a highly inefficient implementation for calculating statistics which could lead to performance degradation, and the introduction of duplicate, conflicting router files for the new feature. On the frontend, I've noted a minor code quality issue regarding redundant state mutation. Addressing these points will significantly improve the security, performance, and maintainability of the new feature.
backend/routers/conversations.py
Outdated
Comment on lines
693
to
708
| @router.get('/v1/conversations/statistics/summary', response_model=dict, tags=['conversations']) | ||
| def get_conversation_statistics(uid: str = Depends(auth.get_current_user_uid)): | ||
| """Get conversation statistics including discard counts""" | ||
| # Get all conversations | ||
| all_convos = conversations_db.get_conversations(uid, limit=10000, offset=0, include_discarded=True) | ||
|
|
||
| stats = { | ||
| 'total_conversations': len(all_convos), | ||
| 'active_count': sum(1 for c in all_convos if c.get('status') == 'completed'), | ||
| 'discarded_count': sum(1 for c in all_convos if c.get('status') == 'discarded'), | ||
| 'processing_count': sum(1 for c in all_convos if c.get('status') == 'processing'), | ||
| 'auto_discarded_count': sum(1 for c in all_convos if c.get('status') == 'discarded' and c.get('discarded_reason') == 'auto_short_duration'), | ||
| 'average_duration': sum(c.get('duration', 0) for c in all_convos) / len(all_convos) if all_convos else 0 | ||
| } | ||
|
|
||
| return stats |
Contributor
There was a problem hiding this comment.
The get_conversation_statistics endpoint fetches up to 10,000 conversation documents for a user and then performs calculations in memory. This is highly inefficient and can lead to significant performance issues, high resource consumption, and slow response times for users with many conversations. It could even be a potential denial-of-service vector.
A more scalable approach should be considered. For Firestore, this typically involves maintaining a separate statistics document for each user that is updated incrementally using Cloud Functions (triggers) whenever a conversation's status or duration changes. This avoids expensive full collection scans on every request.
backend/routers/conversations.py
Outdated
Comment on lines
710
to
815
| @router.get('/v1/test/discarded', tags=['testing']) | ||
| def test_get_discarded_no_auth(): | ||
| """Test endpoint - Get discarded conversations without auth""" | ||
| uid = "test-user-123" | ||
| conversations = conversations_db.get_conversations( | ||
| uid, 100, 0, include_discarded=True, statuses=["discarded"] | ||
| ) | ||
| return {"count": len(conversations), "conversations": conversations} | ||
|
|
||
|
|
||
| @router.get('/v1/test/stats', tags=['testing']) | ||
| def test_get_stats_no_auth(): | ||
| """Test endpoint - Get statistics without auth""" | ||
| uid = "test-user-123" | ||
| all_convos = conversations_db.get_conversations(uid, limit=10000, offset=0, include_discarded=True) | ||
|
|
||
| stats = { | ||
| 'total_conversations': len(all_convos), | ||
| 'active_count': sum(1 for c in all_convos if c.get('status') == 'completed'), | ||
| 'discarded_count': sum(1 for c in all_convos if c.get('status') == 'discarded'), | ||
| 'processing_count': sum(1 for c in all_convos if c.get('status') == 'processing'), | ||
| 'auto_discarded_count': sum(1 for c in all_convos if c.get('status') == 'discarded' and c.get('discarded_reason') == 'auto_short_duration'), | ||
| 'average_duration': sum(c.get('duration', 0) for c in all_convos) / len(all_convos) if all_convos else 0 | ||
| } | ||
| return stats | ||
|
|
||
|
|
||
| @router.post('/v1/test/create-mock', tags=['testing']) | ||
| def test_create_mock_conversation(duration: int = 25): | ||
| """Test endpoint - Create mock conversation without auth""" | ||
| from datetime import datetime, timedelta, timezone | ||
| import uuid | ||
|
|
||
| uid = "test-user-123" | ||
| conv_id = f"test-{uuid.uuid4().hex[:8]}" | ||
| started = datetime.now(timezone.utc) | ||
| finished = started + timedelta(seconds=duration) | ||
|
|
||
| conversation_data = { | ||
| "id": conv_id, | ||
| "user_id": uid, | ||
| "created_at": started, | ||
| "started_at": started, | ||
| "finished_at": finished, | ||
| "duration": duration, | ||
| "status": "completed", | ||
| "transcript": f"Mock test conversation with {duration} seconds duration", | ||
| "language": "en", | ||
| "structured": { | ||
| "title": f"Test Conversation ({duration}s)", | ||
| "overview": "Auto-generated test conversation", | ||
| "action_items": [], | ||
| "events": [] | ||
| }, | ||
| "transcript_segments": [], | ||
| "apps_results": [], | ||
| "plugins_results": [] | ||
| } | ||
|
|
||
| # Save to database | ||
| try: | ||
| conversations_db.upsert_conversation(uid, conversation_data) | ||
|
|
||
| # Trigger auto-discard check | ||
| from utils.conversation_discard import check_and_auto_discard | ||
| conv = Conversation(**conversation_data) | ||
| result = check_and_auto_discard(uid, conv) | ||
|
|
||
| return { | ||
| "success": True, | ||
| "id": conv_id, | ||
| "duration": duration, | ||
| "status": result.status, | ||
| "was_auto_discarded": result.status == "discarded", | ||
| "message": f"Created conversation {conv_id} with {duration}s duration" | ||
| } | ||
| except Exception as e: | ||
| return { | ||
| "success": False, | ||
| "error": str(e), | ||
| "message": "Failed to create conversation" | ||
| } | ||
|
|
||
|
|
||
| @router.post('/v1/test/discard/{conversation_id}', tags=['testing']) | ||
| def test_discard_conversation(conversation_id: str): | ||
| """Test endpoint - Manually discard a conversation without auth""" | ||
| uid = "test-user-123" | ||
| try: | ||
| from utils.conversation_discard import discard_conversation_helper | ||
| result = discard_conversation_helper(uid, conversation_id, 'manual') | ||
| return {"success": True, "conversation": result.dict()} | ||
| except Exception as e: | ||
| return {"success": False, "error": str(e)} | ||
|
|
||
|
|
||
| @router.post('/v1/test/restore/{conversation_id}', tags=['testing']) | ||
| def test_restore_conversation(conversation_id: str): | ||
| """Test endpoint - Restore a conversation without auth""" | ||
| uid = "test-user-123" | ||
| try: | ||
| from utils.conversation_discard import restore_conversation_helper | ||
| result = restore_conversation_helper(uid, conversation_id) | ||
| return {"success": True, "conversation": result.dict()} | ||
| except Exception as e: | ||
| return {"success": False, "error": str(e)} |
Contributor
There was a problem hiding this comment.
The new test endpoints (/v1/test/*) do not have authentication, and some of them perform write operations to the database (e.g., test_create_mock_conversation, test_discard_conversation, test_restore_conversation). Exposing unauthenticated endpoints that can modify data is a significant security vulnerability, especially if this code is deployed to a production environment. These endpoints should either be removed before merging, protected with authentication and authorization, or conditionally registered only in non-production environments.
Comment on lines
1
to
415
| """ | ||
| API Routes for Conversation Auto-Discard Feature | ||
| File: backend/routers/conversations_discard.py | ||
| This module defines the FastAPI routes for managing discarded conversations. | ||
| """ | ||
|
|
||
| from fastapi import APIRouter, Depends, HTTPException, Query, Body | ||
| from typing import List, Optional | ||
| from pydantic import BaseModel | ||
| from datetime import datetime | ||
|
|
||
| from ..database import get_db_client | ||
| from ..auth import get_current_user | ||
| from ..utils.conversations.conversation_helper import ( | ||
| ConversationAutoDiscardService, | ||
| ACTIVE_STATUS, | ||
| DISCARD_STATUS | ||
| ) | ||
|
|
||
| router = APIRouter( | ||
| prefix="/v1/conversations", | ||
| tags=["conversations"] | ||
| ) | ||
|
|
||
|
|
||
| # Request/Response Models | ||
|
|
||
| class DiscardRequest(BaseModel): | ||
| reason: str = 'manual' | ||
|
|
||
| class BulkDeleteRequest(BaseModel): | ||
| conversation_ids: Optional[List[str]] = None | ||
|
|
||
| class ConversationResponse(BaseModel): | ||
| id: str | ||
| user_id: str | ||
| created_at: datetime | ||
| finished_at: Optional[datetime] | ||
| duration: float | ||
| status: str | ||
| discarded_reason: Optional[str] = None | ||
| discarded_at: Optional[datetime] = None # When it was discarded | ||
| transcript: str | ||
| started_at: Optional[datetime] = None # When conversation started | ||
| updated_at: Optional[datetime] = None # Last modification time | ||
|
|
||
| # OPTIONAL BUT RECOMMENDED ⬇️ | ||
| restored_at: Optional[datetime] = None # If/when restored | ||
| summary: Optional[str] = None # AI summary | ||
| title: Optional[str] = None | ||
|
|
||
| class DiscardedConversationsResponse(BaseModel): | ||
| conversations: List[ConversationResponse] | ||
| total: int | ||
| limit: int | ||
| offset: int | ||
|
|
||
|
|
||
| # Endpoints | ||
|
|
||
| @router.get( | ||
| "", | ||
| response_model=List[ConversationResponse], | ||
| summary="Get conversations", | ||
| description="Retrieve conversations with optional status filtering" | ||
| ) | ||
| async def get_conversations( | ||
| status: str = Query(ACTIVE_STATUS, description="Filter by status: active, discarded, or archived"), | ||
| limit: int = Query(50, ge=1, le=100, description="Maximum number of conversations to return"), | ||
| offset: int = Query(0, ge=0, description="Pagination offset"), | ||
| user_id: str = Depends(get_current_user), | ||
| db = Depends(get_db_client) | ||
| ): | ||
| """ | ||
| Get conversations for the authenticated user. | ||
| Query Parameters: | ||
| - status: Filter by conversation status (default: active) | ||
| - limit: Maximum number of results (1-100, default: 50) | ||
| - offset: Pagination offset (default: 0) | ||
| """ | ||
| try: | ||
| query = db.collection('conversations') \ | ||
| .where('user_id', '==', user_id) \ | ||
| .where('status', '==', status) \ | ||
| .order_by('created_at', direction='DESCENDING') \ | ||
| .limit(limit) \ | ||
| .offset(offset) | ||
|
|
||
| conversations = [] | ||
| async for doc in query.stream(): | ||
| conv_data = doc.to_dict() | ||
| conv_data['id'] = doc.id | ||
| conversations.append(conv_data) | ||
|
|
||
| return conversations | ||
|
|
||
| except Exception as e: | ||
| raise HTTPException(status_code=500, detail=f"Failed to fetch conversations: {str(e)}") | ||
|
|
||
|
|
||
| @router.get( | ||
| "/discarded", | ||
| response_model=DiscardedConversationsResponse, | ||
| summary="Get discarded conversations", | ||
| description="Retrieve all discarded conversations for the authenticated user" | ||
| ) | ||
| async def get_discarded_conversations( | ||
| limit: int = Query(50, ge=1, le=100), | ||
| offset: int = Query(0, ge=0), | ||
| user_id: str = Depends(get_current_user), | ||
| db = Depends(get_db_client) | ||
| ): | ||
| """ | ||
| Get all discarded conversations with pagination. | ||
| Returns: | ||
| - conversations: List of discarded conversations | ||
| - total: Total number of discarded conversations | ||
| - limit: Applied limit | ||
| - offset: Applied offset | ||
| """ | ||
| try: | ||
| service = ConversationAutoDiscardService(db) | ||
|
|
||
| # Get conversations | ||
| conversations = await service.get_discarded_conversations( | ||
| user_id=user_id, | ||
| limit=limit, | ||
| offset=offset | ||
| ) | ||
|
|
||
| # Get total count | ||
| count_query = db.collection('conversations') \ | ||
| .where('user_id', '==', user_id) \ | ||
| .where('status', '==', DISCARD_STATUS) | ||
|
|
||
| total = 0 | ||
| async for _ in count_query.stream(): | ||
| total += 1 | ||
|
|
||
| return { | ||
| 'conversations': conversations, | ||
| 'total': total, | ||
| 'limit': limit, | ||
| 'offset': offset | ||
| } | ||
|
|
||
| except Exception as e: | ||
| raise HTTPException(status_code=500, detail=f"Failed to fetch discarded conversations: {str(e)}") | ||
|
|
||
|
|
||
| @router.get( | ||
| "/{conversation_id}", | ||
| response_model=ConversationResponse, | ||
| summary="Get a single conversation", | ||
| description="Retrieve a specific conversation by ID" | ||
| ) | ||
| async def get_conversation( | ||
| conversation_id: str, | ||
| user_id: str = Depends(get_current_user), | ||
| db = Depends(get_db_client) | ||
| ): | ||
| """Get a specific conversation by ID""" | ||
| try: | ||
| doc = await db.collection('conversations').document(conversation_id).get() | ||
|
|
||
| if not doc.exists: | ||
| raise HTTPException(status_code=404, detail="Conversation not found") | ||
|
|
||
| conv_data = doc.to_dict() | ||
| conv_data['id'] = doc.id | ||
|
|
||
| # Verify ownership | ||
| if conv_data.get('user_id') != user_id: | ||
| raise HTTPException(status_code=403, detail="Access denied") | ||
|
|
||
| return conv_data | ||
|
|
||
| except HTTPException: | ||
| raise | ||
| except Exception as e: | ||
| raise HTTPException(status_code=500, detail=f"Failed to fetch conversation: {str(e)}") | ||
|
|
||
|
|
||
| @router.post( | ||
| "/{conversation_id}/discard", | ||
| summary="Discard a conversation", | ||
| description="Manually move a conversation to discarded status" | ||
| ) | ||
| async def discard_conversation( | ||
| conversation_id: str, | ||
| request: DiscardRequest = Body(...), | ||
| user_id: str = Depends(get_current_user), | ||
| db = Depends(get_db_client) | ||
| ): | ||
| """ | ||
| Manually discard a conversation. | ||
| Body Parameters: | ||
| - reason: Reason for discarding (default: 'manual') | ||
| """ | ||
| try: | ||
| # Verify conversation exists and user owns it | ||
| doc = await db.collection('conversations').document(conversation_id).get() | ||
|
|
||
| if not doc.exists: | ||
| raise HTTPException(status_code=404, detail="Conversation not found") | ||
|
|
||
| conv_data = doc.to_dict() | ||
| if conv_data.get('user_id') != user_id: | ||
| raise HTTPException(status_code=403, detail="Access denied") | ||
|
|
||
| # Discard the conversation | ||
| service = ConversationAutoDiscardService(db) | ||
| success = await service.discard_conversation(conversation_id, reason=request.reason) | ||
|
|
||
| if not success: | ||
| raise HTTPException(status_code=500, detail="Failed to discard conversation") | ||
|
|
||
| return { | ||
| "success": True, | ||
| "message": "Conversation discarded successfully", | ||
| "conversation_id": conversation_id | ||
| } | ||
|
|
||
| except HTTPException: | ||
| raise | ||
| except Exception as e: | ||
| raise HTTPException(status_code=500, detail=f"Failed to discard conversation: {str(e)}") | ||
|
|
||
|
|
||
| @router.post( | ||
| "/{conversation_id}/restore", | ||
| summary="Restore a discarded conversation", | ||
| description="Move a discarded conversation back to active status" | ||
| ) | ||
| async def restore_conversation( | ||
| conversation_id: str, | ||
| user_id: str = Depends(get_current_user), | ||
| db = Depends(get_db_client) | ||
| ): | ||
| """ | ||
| Restore a discarded conversation back to active status. | ||
| """ | ||
| try: | ||
| # Verify conversation exists and user owns it | ||
| doc = await db.collection('conversations').document(conversation_id).get() | ||
|
|
||
| if not doc.exists: | ||
| raise HTTPException(status_code=404, detail="Conversation not found") | ||
|
|
||
| conv_data = doc.to_dict() | ||
| if conv_data.get('user_id') != user_id: | ||
| raise HTTPException(status_code=403, detail="Access denied") | ||
|
|
||
| # Verify it's actually discarded | ||
| if conv_data.get('status') != DISCARD_STATUS: | ||
| raise HTTPException(status_code=400, detail="Conversation is not discarded") | ||
|
|
||
| # Restore the conversation | ||
| service = ConversationAutoDiscardService(db) | ||
| success = await service.restore_conversation(conversation_id) | ||
|
|
||
| if not success: | ||
| raise HTTPException(status_code=500, detail="Failed to restore conversation") | ||
|
|
||
| return { | ||
| "success": True, | ||
| "message": "Conversation restored successfully", | ||
| "conversation_id": conversation_id | ||
| } | ||
|
|
||
| except HTTPException: | ||
| raise | ||
| except Exception as e: | ||
| raise HTTPException(status_code=500, detail=f"Failed to restore conversation: {str(e)}") | ||
|
|
||
|
|
||
| @router.post( | ||
| "/discarded/bulk-delete", | ||
| summary="Bulk delete discarded conversations", | ||
| description="Permanently delete multiple or all discarded conversations" | ||
| ) | ||
| async def bulk_delete_discarded( | ||
| request: BulkDeleteRequest = Body(...), | ||
| user_id: str = Depends(get_current_user), | ||
| db = Depends(get_db_client) | ||
| ): | ||
| """ | ||
| Permanently delete discarded conversations. | ||
| Body Parameters: | ||
| - conversation_ids: Optional list of specific conversation IDs to delete. | ||
| If omitted, all discarded conversations will be deleted. | ||
| WARNING: This action cannot be undone! | ||
| """ | ||
| try: | ||
| service = ConversationAutoDiscardService(db) | ||
|
|
||
| deleted_count = await service.bulk_delete_discarded( | ||
| user_id=user_id, | ||
| conversation_ids=request.conversation_ids | ||
| ) | ||
|
|
||
| message = f"Successfully deleted {deleted_count} conversation(s)" | ||
| if request.conversation_ids is None: | ||
| message = f"Successfully deleted all {deleted_count} discarded conversation(s)" | ||
|
|
||
| return { | ||
| "success": True, | ||
| "message": message, | ||
| "deleted_count": deleted_count | ||
| } | ||
|
|
||
| except Exception as e: | ||
| raise HTTPException(status_code=500, detail=f"Failed to delete conversations: {str(e)}") | ||
|
|
||
|
|
||
| @router.get( | ||
| "/statistics/summary", | ||
| summary="Get conversation statistics", | ||
| description="Get summary statistics about conversations" | ||
| ) | ||
| async def get_conversation_statistics( | ||
| user_id: str = Depends(get_current_user), | ||
| db = Depends(get_db_client) | ||
| ): | ||
| """ | ||
| Get summary statistics about user's conversations. | ||
| Returns: | ||
| - total_conversations: Total number of conversations | ||
| - active_count: Number of active conversations | ||
| - discarded_count: Number of discarded conversations | ||
| - archived_count: Number of archived conversations | ||
| - average_duration: Average duration of all conversations | ||
| - auto_discarded_count: Number of auto-discarded conversations | ||
| """ | ||
| try: | ||
| stats = { | ||
| 'total_conversations': 0, | ||
| 'active_count': 0, | ||
| 'discarded_count': 0, | ||
| 'archived_count': 0, | ||
| 'average_duration': 0.0, | ||
| 'auto_discarded_count': 0 | ||
| } | ||
|
|
||
| # Count by status | ||
| for status in [ACTIVE_STATUS, DISCARD_STATUS, 'archived']: | ||
| query = db.collection('conversations') \ | ||
| .where('user_id', '==', user_id) \ | ||
| .where('status', '==', status) | ||
|
|
||
| count = 0 | ||
| total_duration = 0.0 | ||
|
|
||
| async for doc in query.stream(): | ||
| count += 1 | ||
| conv_data = doc.to_dict() | ||
| duration = conv_data.get('duration', 0) | ||
| total_duration += duration | ||
|
|
||
| # Count auto-discarded | ||
| if status == DISCARD_STATUS and conv_data.get('discarded_reason') == 'auto_short_duration': | ||
| stats['auto_discarded_count'] += 1 | ||
|
|
||
| stats[f'{status}_count'] = count | ||
| stats['total_conversations'] += count | ||
|
|
||
| # Calculate average duration | ||
| if stats['total_conversations'] > 0: | ||
| all_conversations = db.collection('conversations').where('user_id', '==', user_id) | ||
| total_duration = 0.0 | ||
| count = 0 | ||
|
|
||
| async for doc in all_conversations.stream(): | ||
| conv_data = doc.to_dict() | ||
| total_duration += conv_data.get('duration', 0) | ||
| count += 1 | ||
|
|
||
| stats['average_duration'] = total_duration / count if count > 0 else 0.0 | ||
|
|
||
| return stats | ||
|
|
||
| except Exception as e: | ||
| raise HTTPException(status_code=500, detail=f"Failed to fetch statistics: {str(e)}") | ||
|
|
||
|
|
||
| # Integration hook for conversation completion | ||
| # This should be called by the main conversation processing logic | ||
|
|
||
| async def on_conversation_completed( | ||
| conversation_id: str, | ||
| user_id: str, | ||
| db | ||
| ) -> dict: | ||
| """ | ||
| Hook that should be called when a conversation is marked as complete. | ||
| This triggers the auto-discard logic. | ||
| Usage: | ||
| from routers.conversations_discard import on_conversation_completed | ||
| result = await on_conversation_completed( | ||
| conversation_id=conv_id, | ||
| user_id=user_id, | ||
| db=db_client | ||
| ) | ||
| """ | ||
| service = ConversationAutoDiscardService(db) | ||
| return await service.process_conversation_completion(conversation_id, user_id) No newline at end of file |
Contributor
There was a problem hiding this comment.
This new file conversations_discard.py seems to introduce a new set of endpoints and logic for handling conversation discarding, which significantly overlaps with the new endpoints added in backend/routers/conversations.py. There are also two different helper modules (utils/conversation_discard.py and utils/conversations/conversation_helper.py) supporting these different router files. This creates ambiguity, code duplication, and potential conflicts. It's unclear which implementation is the intended one. Please consolidate these into a single, consistent implementation to avoid confusion and maintainability issues. If conversations_discard.py is the intended refactoring, the changes in conversations.py should be removed.
Comment on lines
514
to
517
| // Update the local conversation status | ||
| conversation.status = ConversationStatus.completed; | ||
| conversation.discarded = false; | ||
|
|
Contributor
There was a problem hiding this comment.
In restoreConversationLocally, the conversation object is mutated directly before being replaced by restoredConversation from the API response. These mutations are redundant and can be misleading. The restoredConversation object should be treated as the single source of truth for the updated state. Modifying the old object locally can lead to confusion and potential bugs if the replacement logic changes in the future.
Collaborator
i am confusing, tell me more about the real-use case. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
2 participants
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Implement automatic discarding of conversations shorter than 30 seconds with ability to restore them. This helps reduce clutter from accidental or test recordings while preserving user control.
Backend changes:
Frontend changes:
Tested:
Backend API endpoints - Fully tested with curl commands:
-Auto-discard for < 30s conversations: WORKING
-Restore endpoint: WORKING
-Statistics tracking: WORKING
-Test endpoints: ALL WORKING
Code syntax and structure - All verified
-Frontend code follows existing patterns
-Backend code integrates correctly
-No syntax errors
Edge cases handled in code
-Null checks for optional fields
-Status validation
-Proper error handling in API calls