Conversation

create_conversation(request, requesting_user=Depends(get_current_user)) async

Create a new conversation for the current user.

Parameters:

Name	Type	Description	Default
request	ConversationCreate	New conversation payload.	required
requesting_user	User	Authenticated user injected by dependency.	Depends(get_current_user)

Returns:

Type	Description
Conversation	Created conversation.

Raises:

Type	Description
HTTPException	500 for server errors.

Source code in routers/conversation.py

@router.post("/conversations", response_model=Conversation)
async def create_conversation(
    request: ConversationCreate,
    requesting_user: User = Depends(get_current_user),
) -> Conversation:
    """
    Create a new conversation for the current user.

    Args:
        request (ConversationCreate): New conversation payload.
        requesting_user (User): Authenticated user injected by dependency.

    Returns:
        Created conversation.

    Raises:
        HTTPException: 500 for server errors.
    """
    try:
        return await Conversation.create(
            user_id=requesting_user.id,
            name=request.name,
        )

    except HTTPException as e:
        raise e
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Server error: {str(e)}")

delete_conversation(conversation_id, requesting_user=Depends(get_current_user)) async

Delete a conversation and its messages.

Parameters:

Name	Type	Description	Default
conversation_id	str	Conversation identifier.	required
requesting_user	User	Authenticated user injected by dependency.	Depends(get_current_user)

Returns:

Type	Description
dict	Confirmation message.

Raises:

Type	Description
HTTPException	404 if not found; 403 if deletion is forbidden; 500 for server errors.

Source code in routers/conversation.py

@router.delete("/conversations/{conversation_id}")
async def delete_conversation(
    conversation_id: str,
    requesting_user: User = Depends(get_current_user),
) -> dict:
    """
    Delete a conversation and its messages.

    Args:
        conversation_id (str): Conversation identifier.
        requesting_user (User): Authenticated user injected by dependency.

    Returns:
        Confirmation message.

    Raises:
        HTTPException: 404 if not found; 403 if deletion is forbidden; 500 for server errors.
    """
    try:
        conversation = await Conversation.find_by_id(conversation_id)
        if not conversation:
            raise HTTPException(status_code=404, detail="Conversation not found")
        if conversation.user_id != requesting_user.id:
            raise HTTPException(
                status_code=403,
                detail="You are not allowed to delete this conversation",
            )

        await Message.delete_many({"conversation_id": conversation_id})
        await conversation.delete()
        return {"message": "Conversation deleted successfully"}

    except HTTPException as e:
        raise e
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Server error: {str(e)}")

get_conversation(conversation_id, requesting_user=Depends(get_current_user)) async

Get a conversation and its messages.

Parameters:

Name	Type	Description	Default
conversation_id	str	Conversation identifier.	required
requesting_user	User	Authenticated user injected by dependency.	Depends(get_current_user)

Returns:

Type	Description
ConversationDetail	Conversation with messages and metadata.

Raises:

Type	Description
HTTPException	404 if not found; 403 if access is forbidden; 500 for server errors.

Source code in routers/conversation.py

@router.get("/conversations/{conversation_id}", response_model=ConversationDetail)
async def get_conversation(
    conversation_id: str,
    requesting_user: User = Depends(get_current_user),
) -> ConversationDetail:
    """
    Get a conversation and its messages.

    Args:
        conversation_id (str): Conversation identifier.
        requesting_user (User): Authenticated user injected by dependency.

    Returns:
        Conversation with messages and metadata.

    Raises:
        HTTPException: 404 if not found; 403 if access is forbidden; 500 for server errors.
    """
    try:
        conversation = await Conversation.find_by_id(conversation_id)
        if not conversation:
            raise HTTPException(status_code=404, detail="Conversation not found")

        if conversation.user_id != requesting_user.id:
            raise HTTPException(
                status_code=403,
                detail="You are not allowed to get this conversation",
            )

        # Fetch messages for this conversation
        messages = await Message.find_all(
            filter_dict={"conversation_id": conversation_id}, sort=[("timestamp", 1)]
        )

        return ConversationDetail(
            id=conversation.id,
            user_id=conversation.user_id,
            name=conversation.name,
            timestamp=conversation.timestamp,
            messages=messages,
        )

    except HTTPException as e:
        raise e
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Server error: {str(e)}")

list_conversations(request_user=Depends(get_current_user), pagination=Depends()) async

List conversations owned by the current user.

Parameters:

Name	Type	Description	Default
request_user	User	Authenticated user injected by dependency.	Depends(get_current_user)
pagination	Pagination	Pagination parameters.	Depends()

Returns:

Type	Description
PaginatedResponse[Conversation]	Paginated conversations for the user.

Raises:

Type	Description
HTTPException	500 for server errors.

Source code in routers/conversation.py

@router.get("/conversations", response_model=PaginatedResponse[Conversation])
async def list_conversations(
    request_user: User = Depends(get_current_user), pagination: Pagination = Depends()
) -> PaginatedResponse[Conversation]:
    """
    List conversations owned by the current user.

    Args:
        request_user (User): Authenticated user injected by dependency.
        pagination (Pagination): Pagination parameters.

    Returns:
        Paginated conversations for the user.

    Raises:
        HTTPException: 500 for server errors.
    """
    try:
        result = await Conversation.find_all_with_pagination(
            filter_dict={"user_id": request_user.id},
            page=pagination.page,
            limit=pagination.limit,
            sort=[("timestamp", -1)],
        )

        return result

    except HTTPException as e:
        raise e
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Server error: {str(e)}")

update_conversation_name(conversation_id, request, requesting_user=Depends(get_current_user)) async

Update a conversation's name.

Parameters:

Name	Type	Description	Default
conversation_id	str	Conversation identifier.	required
request	ConversationNameUpdate	New name payload.	required
requesting_user	User	Authenticated user injected by dependency.	Depends(get_current_user)

Returns:

Type	Description
Conversation	Updated conversation.

Raises:

Type	Description
HTTPException	404 if not found; 403 if update is forbidden; 500 for server errors.

Source code in routers/conversation.py

@router.patch("/conversations/{conversation_id}")
async def update_conversation_name(
    conversation_id: str,
    request: ConversationNameUpdate,
    requesting_user: User = Depends(get_current_user),
) -> Conversation:
    """
    Update a conversation's name.

    Args:
        conversation_id (str): Conversation identifier.
        request (ConversationNameUpdate): New name payload.
        requesting_user (User): Authenticated user injected by dependency.

    Returns:
        Updated conversation.

    Raises:
        HTTPException: 404 if not found; 403 if update is forbidden; 500 for server errors.
    """
    try:
        conversation = await Conversation.find_by_id(conversation_id)
        if not conversation:
            raise HTTPException(status_code=404, detail="Conversation not found")

        if conversation.user_id != requesting_user.id:
            raise HTTPException(
                status_code=403,
                detail="You are not allowed to update this conversation",
            )

        conversation.name = request.name
        await conversation.save()

        return conversation

    except HTTPException as e:
        raise e
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Server error: {str(e)}")