Conversations

Conversation

Bases: BaseModel

Pydantic model for returning a conversation as a response.

Attributes:

Name	Type	Description
conversation_id	int	Unique identifier for the conversation.
tenant_id	int	The ID of the tenant or organization that owns the conversation.
user_id	int	The ID of the user who created the conversation.
name	Optional[str]	The name of the conversation.
summary	Optional[str]	A brief summary or description of the conversation.
created_at	Optional[datetime]	The timestamp when the conversation was created.
modified_at	Optional[datetime]	The timestamp when the conversation was last modified.
created_by	Optional[str]	The user who originally created the conversation.
modified_by	Optional[str]	The user who last modified the conversation.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

class Conversation(BaseModel):
	"""
	Pydantic model for returning a conversation as a response.

	Attributes:
	    conversation_id (int): Unique identifier for the conversation.
	    tenant_id (int): The ID of the tenant or organization that owns the conversation.
	    user_id (int): The ID of the user who created the conversation.
	    name (Optional[str]): The name of the conversation.
	    summary (Optional[str]): A brief summary or description of the conversation.
	    created_at (Optional[datetime]): The timestamp when the conversation was created.
	    modified_at (Optional[datetime]): The timestamp when the conversation was last modified.
	    created_by (Optional[str]): The user who originally created the conversation.
	    modified_by (Optional[str]): The user who last modified the conversation.
	"""

	conversation_id: int
	tenant_id: int = 1
	user_id: int = 0
	name: Optional[str] = None
	summary: Optional[str] = None
	created_at: Optional[datetime] = None
	modified_at: Optional[datetime] = None
	created_by: Optional[str] = "anonymous"
	modified_by: Optional[str] = "anonymous"

ConversationCreate

Bases: BaseModel

Pydantic model for creating a new conversation.

Attributes:

Name	Type	Description
tenant_id	int	The ID of the tenant or organization creating the conversation. Defaults to 1.
user_id	int	The ID of the user creating the conversation.
name	str	The name of the conversation. Defaults to 'New Conversation'.
summary	Optional[str]	A brief summary or description of the conversation. Defaults to 'No Summary'.
created_by	Optional[str]	The user who created the conversation. Defaults to 'anonymous'.
modified_by	Optional[str]	The user who last modified the conversation. Defaults to 'anonymous'.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

class ConversationCreate(BaseModel):
	"""
	Pydantic model for creating a new conversation.

	Attributes:
	    tenant_id (int): The ID of the tenant or organization creating the conversation. Defaults to 1.
	    user_id (int): The ID of the user creating the conversation.
	    name (str): The name of the conversation. Defaults to 'New Conversation'.
	    summary (Optional[str]): A brief summary or description of the conversation. Defaults to 'No Summary'.
	    created_by (Optional[str]): The user who created the conversation. Defaults to 'anonymous'.
	    modified_by (Optional[str]): The user who last modified the conversation. Defaults to 'anonymous'.
	"""

	tenant_id: int = 1
	user_id: int = 0
	name: str = "New Conversation"
	summary: Optional[str] = "No Summary"
	created_by: Optional[str] = "anonymous"
	modified_by: Optional[str] = "anonymous"

ConversationUpdate

Bases: BaseModel

Pydantic model for updating an existing conversation.

Attributes:

Name	Type	Description
tenant_id	Optional[int]	The updated tenant ID, if provided.
user_id	Optional[int]	The updated user ID, if provided.
name	Optional[str]	The updated name of the conversation, if provided.
summary	Optional[str]	The updated summary of the conversation, if provided.
created_by	Optional[str]	The user who originally created the conversation. Defaults to 'anonymous'.
modified_by	Optional[str]	The user who last modified the conversation. Defaults to 'anonymous'.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

class ConversationUpdate(BaseModel):
	"""
	Pydantic model for updating an existing conversation.

	Attributes:
	    tenant_id (Optional[int]): The updated tenant ID, if provided.
	    user_id (Optional[int]): The updated user ID, if provided.
	    name (Optional[str]): The updated name of the conversation, if provided.
	    summary (Optional[str]): The updated summary of the conversation, if provided.
	    created_by (Optional[str]): The user who originally created the conversation. Defaults to 'anonymous'.
	    modified_by (Optional[str]): The user who last modified the conversation. Defaults to 'anonymous'.
	"""

	tenant_id: Optional[int] = None
	user_id: Optional[int] = None
	name: Optional[str] = None
	summary: Optional[str] = None
	created_by: Optional[str] = "anonymous"
	modified_by: Optional[str] = "anonymous"

Message

Bases: BaseModel

Pydantic model representing an individual message within a conversation.

Attributes:

Name	Type	Description
message_id	int	Unique identifier for the message.
conversation_id	int	The ID of the conversation the message belongs to.
role	RoleType	The role of the message sender, either 'user' or 'assistant'.
content	Optional[str]	The text content of the message.
parent_message_id	Optional[int]	The ID of the parent message, if this is a reply to another message.
timestamp	Optional[datetime]	The timestamp indicating when the message was created.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

class Message(BaseModel):
	"""
	Pydantic model representing an individual message within a conversation.

	Attributes:
	    message_id (int): Unique identifier for the message.
	    conversation_id (int): The ID of the conversation the message belongs to.
	    role (RoleType): The role of the message sender, either 'user' or 'assistant'.
	    content (Optional[str]): The text content of the message.
	    parent_message_id (Optional[int]): The ID of the parent message, if this is a reply to another message.
	    timestamp (Optional[datetime]): The timestamp indicating when the message was created.
	"""

	message_id: int = None
	conversation_id: int = None
	role: RoleType
	content: Optional[str] = None
	parent_message_id: Optional[int] = None
	timestamp: Optional[datetime] = None

MessageCreate

Bases: BaseModel

Pydantic model for creating a new message.

Attributes:

Name	Type	Description
role	str	The role of the message sender, either 'user' or 'assistant'.
content	Optional[str]	The text content of the message.
parent_message_id	Optional[int]	The ID of the parent message, if this message is a reply.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

class MessageCreate(BaseModel):
	"""
	Pydantic model for creating a new message.

	Attributes:
	    role (str): The role of the message sender, either 'user' or 'assistant'.
	    content (Optional[str]): The text content of the message.
	    parent_message_id (Optional[int]): The ID of the parent message, if this message is a reply.
	"""

	role: str  # RoleType, e.g., 'user' or 'assistant'
	content: Optional[str] = None
	parent_message_id: Optional[int] = None  # Parent message ID, optional for user messages

MessageFlag

Bases: BaseModel

Pydantic model for returning an existing message flag.

Attributes:

Name	Type	Description
message_flag_id	int	Unique identifier of the message flag.
message_id	int	The ID of the message that the flag is associated with.
flag	FlagType	The type of flag applied to the message (e.g., incorrect, praise, suggestion, other).
comment	Optional[str]	Optional comment providing additional details about the flag.
created_at	datetime	The timestamp indicating when the flag was created.
created_by	Optional[str]	The identifier (username or ID) of the user who created the flag.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

class MessageFlag(BaseModel):
	"""
	Pydantic model for returning an existing message flag.

	Attributes:
	    message_flag_id (int): Unique identifier of the message flag.
	    message_id (int): The ID of the message that the flag is associated with.
	    flag (FlagType): The type of flag applied to the message (e.g., incorrect, praise, suggestion, other).
	    comment (Optional[str]): Optional comment providing additional details about the flag.
	    created_at (datetime): The timestamp indicating when the flag was created.
	    created_by (Optional[str]): The identifier (username or ID) of the user who created the flag.
	"""

	message_flag_id: int
	message_id: int
	flag: FlagType
	comment: Optional[str] = None
	created_at: datetime
	created_by: Optional[str] = None

MessageFlagCreate

Bases: BaseModel

Pydantic model for creating a new message flag.

Attributes:

Name	Type	Description
flag	FlagType	The type of flag to apply to the message. Must be one of ['incorrect', 'praise', 'suggestion', 'other'].
comment	Optional[str]	Optional comment providing additional details about why the flag is being applied. Max length: 1000 characters.
created_by	Optional[str]	The identifier (username or ID) of the user creating the flag. Defaults to 'anonymous' if not provided.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

class MessageFlagCreate(BaseModel):
	"""
	Pydantic model for creating a new message flag.

	Attributes:
	    flag (FlagType): The type of flag to apply to the message. Must be one of ['incorrect', 'praise', 'suggestion', 'other'].
	    comment (Optional[str]): Optional comment providing additional details about why the flag is being applied. Max length: 1000 characters.
	    created_by (Optional[str]): The identifier (username or ID) of the user creating the flag. Defaults to 'anonymous' if not provided.
	"""

	flag: FlagType  # Enum value (incorrect, praise, suggestion, other)
	comment: Optional[str] = None
	created_by: Optional[str] = "anonymous"

	@validator("comment")
	def validate_comment_length(cls, v):
		"""Ensures the comment, if provided, is not excessively long."""
		if v and len(v) > 1000:
			raise ValueError("Comment must be 1000 characters or less")
		return v

validate_comment_length(v)

Ensures the comment, if provided, is not excessively long.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

@validator("comment")
def validate_comment_length(cls, v):
	"""Ensures the comment, if provided, is not excessively long."""
	if v and len(v) > 1000:
		raise ValueError("Comment must be 1000 characters or less")
	return v

MessageFlagUpdate

Bases: BaseModel

Pydantic model for updating an existing message flag.

Attributes:

Name	Type	Description
flag	Optional[FlagType]	Updated flag type, if provided.
comment	Optional[str]	Updated comment associated with the flag. Max length: 1000 characters.
created_by	Optional[str]	The user who updated the flag, if this information is needed for audit purposes.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

class MessageFlagUpdate(BaseModel):
	"""
	Pydantic model for updating an existing message flag.

	Attributes:
	    flag (Optional[FlagType]): Updated flag type, if provided.
	    comment (Optional[str]): Updated comment associated with the flag. Max length: 1000 characters.
	    created_by (Optional[str]): The user who updated the flag, if this information is needed for audit purposes.
	"""

	flag: Optional[FlagType] = None
	comment: Optional[str] = None
	created_by: Optional[str] = "anonymous"

	@validator("comment")
	def validate_comment_length(cls, v):
		"""Ensures the comment, if provided, does not exceed the maximum length."""
		if v and len(v) > 1000:
			raise ValueError("Comment must be 1000 characters or less")
		return v

validate_comment_length(v)

Ensures the comment, if provided, does not exceed the maximum length.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

@validator("comment")
def validate_comment_length(cls, v):
	"""Ensures the comment, if provided, does not exceed the maximum length."""
	if v and len(v) > 1000:
		raise ValueError("Comment must be 1000 characters or less")
	return v

MessageSQL

Bases: BaseModel

Pydantic model for returning a created MessageSQL entry.

Attributes:

Name	Type	Description
message_sql_id	int	Unique identifier for the SQL entry.
message_id	int	The ID of the message associated with this SQL entry.
query_generated	str	The generated SQL query.
query_results	str	The results of the SQL query execution, stored as a JSON string or raw text.
created_at	datetime	Timestamp indicating when the SQL entry was created.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

class MessageSQL(BaseModel):
	"""
	Pydantic model for returning a created MessageSQL entry.

	Attributes:
	    message_sql_id (int): Unique identifier for the SQL entry.
	    message_id (int): The ID of the message associated with this SQL entry.
	    query_generated (str): The generated SQL query.
	    query_results (str): The results of the SQL query execution, stored as a JSON string or raw text.
	    created_at (datetime): Timestamp indicating when the SQL entry was created.
	"""

	message_sql_id: int
	message_id: int
	query_generated: str
	query_results: str
	created_at: datetime

MessageSQLCreate

Bases: BaseModel

Pydantic model for creating a new MessageSQL entry.

Attributes:

Name	Type	Description
sql_query	str	The SQL query that was generated in response to a user message.
sql_results	Union[str, List[dict]]	The raw results of the executed SQL query. Can be either a string or a list of dictionaries.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

class MessageSQLCreate(BaseModel):
	"""
	Pydantic model for creating a new MessageSQL entry.

	Attributes:
	    sql_query (str): The SQL query that was generated in response to a user message.
	    sql_results (Union[str, List[dict]]): The raw results of the executed SQL query. Can be either a string or a list of dictionaries.
	"""

	sql_query: str  # The generated SQL query
	sql_results: Union[str, List[dict]]  # The results of the query, stored as either a string or list of dicts

	@validator("sql_results", pre=True, always=True)
	def stringify_results(cls, v):
		"""
		Convert list of dictionaries to a JSON-formatted string for storage, if necessary.
		This ensures that SQL results can be stored in a text field.
		"""
		if isinstance(v, list):
			return json.dumps(v)  # Convert list of dicts to a JSON string
		return v  # Return as-is if it's already a string

stringify_results(v)

Convert list of dictionaries to a JSON-formatted string for storage, if necessary. This ensures that SQL results can be stored in a text field.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

@validator("sql_results", pre=True, always=True)
def stringify_results(cls, v):
	"""
	Convert list of dictionaries to a JSON-formatted string for storage, if necessary.
	This ensures that SQL results can be stored in a text field.
	"""
	if isinstance(v, list):
		return json.dumps(v)  # Convert list of dicts to a JSON string
	return v  # Return as-is if it's already a string

MessageSQLUpdate

Bases: BaseModel

Pydantic model for updating an existing MessageSQL entry.

Attributes:

Name	Type	Description
sql_query	Optional[str]	The updated SQL query.
sql_results	Optional[Union[str, List[dict]]]	The updated raw results of the SQL query.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

class MessageSQLUpdate(BaseModel):
	"""
	Pydantic model for updating an existing MessageSQL entry.

	Attributes:
	    sql_query (Optional[str]): The updated SQL query.
	    sql_results (Optional[Union[str, List[dict]]]): The updated raw results of the SQL query.
	"""

	sql_query: Optional[str] = None
	sql_results: Optional[Union[str, List[dict]]] = None

	@validator("sql_results", pre=True, always=True)
	def stringify_results(cls, v):
		"""
		Convert list of dictionaries to a JSON-formatted string for storage, if necessary.
		This ensures that SQL results can be stored in a text field.
		"""
		if isinstance(v, list):
			return json.dumps(v)  # Convert list of dicts to a JSON string
		return v  # Return as-is if it's already a string

stringify_results(v)

Convert list of dictionaries to a JSON-formatted string for storage, if necessary. This ensures that SQL results can be stored in a text field.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

@validator("sql_results", pre=True, always=True)
def stringify_results(cls, v):
	"""
	Convert list of dictionaries to a JSON-formatted string for storage, if necessary.
	This ensures that SQL results can be stored in a text field.
	"""
	if isinstance(v, list):
		return json.dumps(v)  # Convert list of dicts to a JSON string
	return v  # Return as-is if it's already a string

MessageUpdate

Bases: BaseModel

Pydantic model for updating an existing message.

Attributes:

Name	Type	Description
content	Optional[str]	The updated content of the message, if provided.
parent_message_id	Optional[int]	The ID of the parent message, if this message is a reply.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

class MessageUpdate(BaseModel):
	"""
	Pydantic model for updating an existing message.

	Attributes:
	    content (Optional[str]): The updated content of the message, if provided.
	    parent_message_id (Optional[int]): The ID of the parent message, if this message is a reply.
	"""

	content: Optional[str] = None
	parent_message_id: Optional[int] = None

conversation_model_to_pydantic(conversation_model)

Converts a ConversationModel instance into a Pydantic Conversation model.

Parameters:

Name	Type	Description	Default
conversation_model	ConversationModel	SQLAlchemy conversation model.	required

Returns:

Name	Type	Description
Conversation	Conversation	Pydantic representation of the conversation.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

def conversation_model_to_pydantic(conversation_model: ConversationModel) -> Conversation:
	"""
	Converts a ConversationModel instance into a Pydantic Conversation model.

	Args:
	    conversation_model (ConversationModel): SQLAlchemy conversation model.

	Returns:
	    Conversation: Pydantic representation of the conversation.
	"""

	return Conversation(
		conversation_id=conversation_model.conversation_id,
		tenant_id=conversation_model.tenant_id,
		user_id=conversation_model.user_id,
		name=conversation_model.name,
		summary=conversation_model.summary,
		created_at=conversation_model.created_at,
		modified_at=conversation_model.modified_at,
		created_by=conversation_model.created_by,
		modified_by=conversation_model.modified_by,
	)

create_conversation(conversation, session=Depends(my_cxo_db_conn.get_db_sess)) async

Creates a new conversation without handling any messages.

Parameters:

Name	Type	Description	Default
conversation	ConversationCreate	The conversation data to create.	required
session	AsyncSession	The database session.	Depends(get_db_sess)

Returns:

Name	Type	Description
Conversation		The created conversation.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

@conversation_router.post("/", response_model=Conversation)
async def create_conversation(conversation: ConversationCreate, session: AsyncSession = Depends(my_cxo_db_conn.get_db_sess)):
	"""
	Creates a new conversation without handling any messages.

	Args:
	    conversation (ConversationCreate): The conversation data to create.
	    session (AsyncSession): The database session.

	Returns:
	    Conversation: The created conversation.
	"""
	try:
		# Create the conversation with the provided data
		new_conversation = ConversationModel(
			tenant_id=conversation.tenant_id,
			user_id=conversation.user_id,
			name=conversation.name,
			summary=conversation.summary,
			created_by=conversation.created_by or "anonymous",
			modified_by=conversation.created_by or "anonymous",
		)

		# Add the new conversation to the session and commit
		session.add(new_conversation)
		await session.commit()
		await session.refresh(new_conversation)

		# Convert the conversation to a Pydantic model and return
		return conversation_model_to_pydantic(new_conversation)

	except SQLAlchemyError as e:
		await session.rollback()
		logging.exception("Error creating conversation")
		raise HTTPException(status_code=500, detail=str(e))

create_message(conversation_id, message, session=Depends(my_cxo_db_conn.get_db_sess)) async

Creates a new message for a conversation. If the message role is 'assistant', the frontend should pass the parent_message_id, which is the user message that triggered it.

Parameters:

Name	Type	Description	Default
conversation_id	int	ID of the conversation this message belongs to.	required
message	MessageCreate	The message data to create.	required
session	AsyncSession	The database session.	Depends(get_db_sess)

Returns:

Name	Type	Description
Message		The created message.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

@conversation_router.post("/{conversation_id}/messages/", response_model=Message)
async def create_message(conversation_id: int, message: MessageCreate, session: AsyncSession = Depends(my_cxo_db_conn.get_db_sess)):
	"""
	Creates a new message for a conversation. If the message role is 'assistant',
	the frontend should pass the parent_message_id, which is the user message that triggered it.

	Args:
	    conversation_id (int): ID of the conversation this message belongs to.
	    message (MessageCreate): The message data to create.
	    session (AsyncSession): The database session.

	Returns:
	    Message: The created message.
	"""
	try:
		# Check if the conversation exists
		result = await session.execute(select(ConversationModel).where(ConversationModel.conversation_id == conversation_id))
		conversation = result.scalar_one_or_none()
		if not conversation:
			raise HTTPException(status_code=404, detail="Conversation not found")

		# Create the message
		new_message = MessageModel(
			conversation_id=conversation_id,
			role=message.role,
			content=message.content,
			parent_message_id=message.parent_message_id,
			created_by=conversation.modified_by,  # Assuming created_by is the one modifying the conversation
			timestamp=datetime.utcnow(),
		)
		session.add(new_message)

		# Update the conversation metadata (modified_at and modified_by)
		conversation.modified_at = datetime.utcnow()
		conversation.modified_by = new_message.created_by

		# Commit changes
		await session.commit()
		await session.refresh(new_message)

		# Return the created message
		return new_message

	except SQLAlchemyError as e:
		await session.rollback()
		logging.exception("Error creating message")
		raise HTTPException(status_code=500, detail=str(e))

create_message_flag(conversation_id, message_id, message_flag, session=Depends(my_cxo_db_conn.get_db_sess)) async

Creates a new message flag for a specific message within a conversation.

This method allows users to create flags (e.g., incorrect, praise, suggestion, other) for individual messages. It first ensures that both the conversation and message exist, then creates the flag with the appropriate details provided by the user.

Parameters:

Name	Type	Description	Default
conversation_id	int	ID of the conversation that contains the message to flag.	required
message_id	int	ID of the message to be flagged.	required
message_flag	MessageFlagCreate	The flag data to create, which includes the flag type and an optional comment.	required
session	AsyncSession	The SQLAlchemy async session for database interaction.	Depends(get_db_sess)

Returns:

Name	Type	Description
MessageFlag		The newly created message flag object.

Raises:

Type	Description
HTTPException	If the conversation or message cannot be found, or if a database error occurs.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

@conversation_router.post(
	"/{conversation_id}/messages/{message_id}/flags/",
	response_model=MessageFlag,
	status_code=201,
	summary="Create a message flag",
	description="Create a flag for a specific message within a conversation.",
)
async def create_message_flag(conversation_id: int, message_id: int, message_flag: MessageFlagCreate, session: AsyncSession = Depends(my_cxo_db_conn.get_db_sess)):
	"""
	Creates a new message flag for a specific message within a conversation.

	This method allows users to create flags (e.g., incorrect, praise, suggestion, other) for individual messages.
	It first ensures that both the conversation and message exist, then creates the flag with the appropriate
	details provided by the user.

	Args:
	    conversation_id (int): ID of the conversation that contains the message to flag.
	    message_id (int): ID of the message to be flagged.
	    message_flag (MessageFlagCreate): The flag data to create, which includes the flag type and an optional comment.
	    session (AsyncSession): The SQLAlchemy async session for database interaction.

	Returns:
	    MessageFlag: The newly created message flag object.

	Raises:
	    HTTPException: If the conversation or message cannot be found, or if a database error occurs.
	"""
	try:
		# Step 1: Ensure the conversation exists in the database
		result = await session.execute(select(ConversationModel).where(ConversationModel.conversation_id == conversation_id))
		conversation = result.scalar_one_or_none()

		if not conversation:
			raise HTTPException(status_code=404, detail="Conversation not found")

		# Step 2: Ensure the message exists in the conversation
		result = await session.execute(select(MessageModel).where(MessageModel.message_id == message_id, MessageModel.conversation_id == conversation_id))
		message = result.scalar_one_or_none()

		if not message:
			raise HTTPException(status_code=404, detail="Message not found in the specified conversation")

		# Step 3: Create a new message flag based on the provided data
		new_flag = MessageFlagModel(
			message_id=message_id,
			flag=message_flag.flag,
			comment=message_flag.comment,
			created_by=message_flag.created_by or "anonymous",  # Use 'anonymous' if no creator is specified
		)

		# Add the new flag to the session and commit the transaction
		session.add(new_flag)
		await session.commit()
		await session.refresh(new_flag)

		# Step 4: Return the newly created flag
		return MessageFlag(
			message_flag_id=new_flag.message_flag_id,
			message_id=new_flag.message_id,
			flag=new_flag.flag,
			comment=new_flag.comment,
			created_at=new_flag.created_at,
			created_by=new_flag.created_by,
		)

	except SQLAlchemyError:
		# Rollback in case of a failure during the transaction
		await session.rollback()
		logging.exception("Error while creating a message flag")
		raise HTTPException(status_code=500, detail="Internal server error")

create_message_sql(conversation_id, message_id, message_sql_data, session=Depends(my_cxo_db_conn.get_db_sess)) async

Creates a new SQL query and results entry for a specific message within a conversation.

This method first ensures that the conversation and message exist. Then, it takes the SQL query and results provided in the request and stores them in the 'message_sql' table, associating them with the correct message.

Parameters:

Name	Type	Description	Default
conversation_id	int	ID of the conversation that contains the message.	required
message_id	int	ID of the message for which the SQL query and results are to be created.	required
message_sql_data	MessageSQLCreate	Pydantic model containing the SQL query and results to store.	required
session	AsyncSession	The SQLAlchemy async session for database interaction.	Depends(get_db_sess)

Returns:

Name	Type	Description
MessageSQL		The newly created MessageSQL object containing the query and results.

Raises:

Type	Description
HTTPException	If the conversation or message cannot be found, or if a database error occurs.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

@conversation_router.post(
	"/{conversation_id}/messages/{message_id}/sql/",
	response_model=MessageSQL,
	status_code=201,
	summary="Create SQL entry for a message",
	description="Create an SQL query and its results for a specific message.",
)
async def create_message_sql(conversation_id: int, message_id: int, message_sql_data: MessageSQLCreate, session: AsyncSession = Depends(my_cxo_db_conn.get_db_sess)):
	"""
	Creates a new SQL query and results entry for a specific message within a conversation.

	This method first ensures that the conversation and message exist. Then, it takes the SQL query and results
	provided in the request and stores them in the 'message_sql' table, associating them with the correct message.

	Args:
	    conversation_id (int): ID of the conversation that contains the message.
	    message_id (int): ID of the message for which the SQL query and results are to be created.
	    message_sql_data (MessageSQLCreate): Pydantic model containing the SQL query and results to store.
	    session (AsyncSession): The SQLAlchemy async session for database interaction.

	Returns:
	    MessageSQL: The newly created MessageSQL object containing the query and results.

	Raises:
	    HTTPException: If the conversation or message cannot be found, or if a database error occurs.
	"""
	try:
		# Step 1: Ensure the conversation exists in the database
		result = await session.execute(select(ConversationModel).where(ConversationModel.conversation_id == conversation_id))
		conversation = result.scalar_one_or_none()

		if not conversation:
			raise HTTPException(status_code=404, detail="Conversation not found")

		# Step 2: Ensure the message exists in the conversation
		result = await session.execute(select(MessageModel).where(MessageModel.message_id == message_id, MessageModel.conversation_id == conversation_id))
		message = result.scalar_one_or_none()

		if not message:
			raise HTTPException(status_code=404, detail="Message not found in the specified conversation")

		# Step 3: Convert the SQL results to a string if necessary
		query_results_str = json.dumps(message_sql_data.sql_results) if isinstance(message_sql_data.sql_results, list) else message_sql_data.sql_results

		# Step 4: Create the SQL entry
		new_message_sql = MessageSQLModel(
			message_id=message_id,
			query_generated=message_sql_data.sql_query,  # Store the SQL query
			query_results=query_results_str,  # Ensure query_results is stored as a string
			created_at=datetime.utcnow(),
		)

		# Step 5: Add the new SQL entry to the session and commit
		session.add(new_message_sql)
		await session.commit()
		await session.refresh(new_message_sql)

		# Step 6: Return the newly created SQL entry
		return MessageSQL(
			message_sql_id=new_message_sql.message_sql_id,
			message_id=new_message_sql.message_id,
			query_generated=new_message_sql.query_generated,
			query_results=new_message_sql.query_results,
			created_at=new_message_sql.created_at,
		)

	except SQLAlchemyError:
		# Rollback in case of any failure during the transaction
		await session.rollback()
		logging.exception("Error while creating SQL entry for the message")
		raise HTTPException(status_code=500, detail="Internal server error")

get_conversations(conversation_ids=Query(None), session=Depends(my_cxo_db_conn.get_db_sess)) async

Retrieves conversations from the database. If conversation_ids is provided, it will return only the specific conversations with the given IDs. Otherwise, it will return all conversations.

Parameters:

Name	Type	Description	Default
conversation_ids	List[int]	List of conversation IDs to retrieve.	Query(None)
session	AsyncSession	The database session.	Depends(get_db_sess)

Returns:

Type	Description
	List[Conversation]: List of conversations.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

@conversation_router.get("/", response_model=List[Conversation])
async def get_conversations(
	conversation_ids: Optional[List[int]] = Query(None),  # List of conversation_ids as a query parameter
	session: AsyncSession = Depends(my_cxo_db_conn.get_db_sess),
):
	"""
	Retrieves conversations from the database.
	If `conversation_ids` is provided, it will return only the specific conversations with the given IDs.
	Otherwise, it will return all conversations.

	Args:
	    conversation_ids (List[int], optional): List of conversation IDs to retrieve.
	    session (AsyncSession): The database session.

	Returns:
	    List[Conversation]: List of conversations.
	"""
	try:
		# If conversation_ids is provided, retrieve only those conversations
		if conversation_ids:
			result = await session.execute(select(ConversationModel).where(ConversationModel.conversation_id.in_(conversation_ids)))
		else:
			# Otherwise, retrieve all conversations
			result = await session.execute(select(ConversationModel))

		conversation_models = result.scalars().all()

		# Convert SQLAlchemy models to Pydantic models
		conversations = [conversation_model_to_pydantic(c) for c in conversation_models]
		return conversations

	except SQLAlchemyError as e:
		logging.exception("Error retrieving conversations")
		raise HTTPException(status_code=500, detail=str(e))

get_message_flags(conversation_id, message_id, message_flag_ids=Query(None), session=Depends(my_cxo_db_conn.get_db_sess)) async

Retrieves one, some, or all message flags for a specific message within a conversation.

This method first checks if the conversation and message exist, then fetches the flags associated with the given message. If message_flag_ids are provided, it will retrieve only the specified flags. Otherwise, it will return all flags associated with the message.

Parameters:

Name	Type	Description	Default
conversation_id	int	ID of the conversation containing the message.	required
message_id	int	ID of the message for which the flags are to be retrieved.	required
message_flag_ids	List[int]	List of specific flag IDs to retrieve. Defaults to None (all flags).	Query(None)
session	AsyncSession	The SQLAlchemy async session for database interaction.	Depends(get_db_sess)

Returns:

Type	Description
	List[MessageFlag]: A list of message flags, either specific ones or all flags associated with the message.

Raises:

Type	Description
HTTPException	If the conversation or message cannot be found, or if a database error occurs.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

@conversation_router.get(
	"/{conversation_id}/messages/{message_id}/flags/",
	response_model=List[MessageFlag],
	summary="Get message flags",
	description="Retrieve one, some, or all message flags for a specific message in a conversation.",
)
async def get_message_flags(
	conversation_id: int,
	message_id: int,
	message_flag_ids: Optional[List[int]] = Query(None),  # Optional list of flag IDs
	session: AsyncSession = Depends(my_cxo_db_conn.get_db_sess),
):
	"""
	Retrieves one, some, or all message flags for a specific message within a conversation.

	This method first checks if the conversation and message exist, then fetches the flags associated
	with the given message. If `message_flag_ids` are provided, it will retrieve only the specified flags.
	Otherwise, it will return all flags associated with the message.

	Args:
	    conversation_id (int): ID of the conversation containing the message.
	    message_id (int): ID of the message for which the flags are to be retrieved.
	    message_flag_ids (List[int], optional): List of specific flag IDs to retrieve. Defaults to None (all flags).
	    session (AsyncSession): The SQLAlchemy async session for database interaction.

	Returns:
	    List[MessageFlag]: A list of message flags, either specific ones or all flags associated with the message.

	Raises:
	    HTTPException: If the conversation or message cannot be found, or if a database error occurs.
	"""
	try:
		# Step 1: Ensure the conversation exists in the database
		result = await session.execute(select(ConversationModel).where(ConversationModel.conversation_id == conversation_id))
		conversation = result.scalar_one_or_none()

		if not conversation:
			raise HTTPException(status_code=404, detail="Conversation not found")

		# Step 2: Ensure the message exists in the conversation
		result = await session.execute(select(MessageModel).where(MessageModel.message_id == message_id, MessageModel.conversation_id == conversation_id))
		message = result.scalar_one_or_none()

		if not message:
			raise HTTPException(status_code=404, detail="Message not found in the specified conversation")

		# Step 3: Retrieve the flags associated with the message
		if message_flag_ids:
			# If specific flag IDs are provided, filter by those
			result = await session.execute(select(MessageFlagModel).where(MessageFlagModel.message_id == message_id, MessageFlagModel.message_flag_id.in_(message_flag_ids)))
		else:
			# Otherwise, retrieve all flags for the message
			result = await session.execute(select(MessageFlagModel).where(MessageFlagModel.message_id == message_id))

		flags = result.scalars().all()

		# Step 4: Return the flags in Pydantic model format by passing the SQLAlchemy object fields
		return [
			MessageFlag(message_flag_id=flag.message_flag_id, message_id=flag.message_id, flag=flag.flag, comment=flag.comment, created_at=flag.created_at, created_by=flag.created_by)
			for flag in flags
		]

	except SQLAlchemyError:
		# Rollback in case of any database errors and raise an HTTP exception
		logging.exception("Error retrieving message flags")
		raise HTTPException(status_code=500, detail="Internal server error")

get_message_sql(conversation_id, message_id, session=Depends(my_cxo_db_conn.get_db_sess)) async

Retrieves the SQL query and results for a specific message within a conversation.

This method first ensures that the conversation and message exist. Then, it retrieves the associated SQL entry for the message, if it exists.

Parameters:

Name	Type	Description	Default
conversation_id	int	ID of the conversation that contains the message.	required
message_id	int	ID of the message for which the SQL query and results are to be retrieved.	required
session	AsyncSession	The SQLAlchemy async session for database interaction.	Depends(get_db_sess)

Returns:

Name	Type	Description
MessageSQL		The MessageSQL object containing the query and results, if found.

Raises:

Type	Description
HTTPException	If the conversation, message, or message SQL entry cannot be found.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

@conversation_router.get(
	"/{conversation_id}/messages/{message_id}/sql/",
	response_model=MessageSQL,
	summary="Get SQL entry for a message",
	description="Retrieve the SQL query and results for a specific message.",
)
async def get_message_sql(conversation_id: int, message_id: int, session: AsyncSession = Depends(my_cxo_db_conn.get_db_sess)):
	"""
	Retrieves the SQL query and results for a specific message within a conversation.

	This method first ensures that the conversation and message exist. Then, it retrieves the
	associated SQL entry for the message, if it exists.

	Args:
	    conversation_id (int): ID of the conversation that contains the message.
	    message_id (int): ID of the message for which the SQL query and results are to be retrieved.
	    session (AsyncSession): The SQLAlchemy async session for database interaction.

	Returns:
	    MessageSQL: The MessageSQL object containing the query and results, if found.

	Raises:
	    HTTPException: If the conversation, message, or message SQL entry cannot be found.
	"""
	try:
		# Step 1: Ensure the conversation exists in the database
		result = await session.execute(select(ConversationModel).where(ConversationModel.conversation_id == conversation_id))
		conversation = result.scalar_one_or_none()

		if not conversation:
			raise HTTPException(status_code=404, detail="Conversation not found")

		# Step 2: Ensure the message exists in the conversation
		result = await session.execute(select(MessageModel).where(MessageModel.message_id == message_id, MessageModel.conversation_id == conversation_id))
		message = result.scalar_one_or_none()

		if not message:
			raise HTTPException(status_code=404, detail="Message not found in the specified conversation")

		# Step 3: Retrieve the SQL entry for the message
		result = await session.execute(select(MessageSQLModel).where(MessageSQLModel.message_id == message_id))
		message_sql = result.scalar_one_or_none()

		if not message_sql:
			raise HTTPException(status_code=404, detail="Message SQL entry not found")

		# Step 4: Return the retrieved SQL entry
		return MessageSQL(
			message_sql_id=message_sql.message_sql_id,
			message_id=message_sql.message_id,
			query_generated=message_sql.query_generated,
			query_results=message_sql.query_results,
			created_at=message_sql.created_at,
		)

	except SQLAlchemyError:
		logging.exception("Error while retrieving SQL entry for the message")
		raise HTTPException(status_code=500, detail="Internal server error")

get_messages(conversation_id, message_ids=Query(None), session=Depends(my_cxo_db_conn.get_db_sess)) async

Retrieves messages from a conversation. If message_ids is provided, it will return only those messages. Otherwise, it will return all messages for the conversation.

Parameters:

Name	Type	Description	Default
conversation_id	int	ID of the conversation to fetch messages from.	required
message_ids	List[int]	List of message IDs to retrieve.	Query(None)
session	AsyncSession	The database session.	Depends(get_db_sess)

Returns:

Type	Description
	List[Message]: List of messages.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

@conversation_router.get("/{conversation_id}/messages/", response_model=List[Message])
async def get_messages(
	conversation_id: int,
	message_ids: Optional[List[int]] = Query(None),  # List of message_ids as a query parameter
	session: AsyncSession = Depends(my_cxo_db_conn.get_db_sess),
):
	"""
	Retrieves messages from a conversation. If `message_ids` is provided, it will return
	only those messages. Otherwise, it will return all messages for the conversation.

	Args:
	    conversation_id (int): ID of the conversation to fetch messages from.
	    message_ids (List[int], optional): List of message IDs to retrieve.
	    session (AsyncSession): The database session.

	Returns:
	    List[Message]: List of messages.
	"""
	try:
		# Check if the conversation exists
		result = await session.execute(select(ConversationModel).where(ConversationModel.conversation_id == conversation_id))
		conversation = result.scalar_one_or_none()
		if not conversation:
			raise HTTPException(status_code=404, detail="Conversation not found")

		# Fetch messages based on the provided message_ids or all if None
		if message_ids:
			result = await session.execute(select(MessageModel).where(MessageModel.conversation_id == conversation_id, MessageModel.message_id.in_(message_ids)))
		else:
			result = await session.execute(select(MessageModel).where(MessageModel.conversation_id == conversation_id))

		messages = result.scalars().all()
		return messages

	except SQLAlchemyError as e:
		logging.exception("Error fetching messages")
		raise HTTPException(status_code=500, detail=str(e))

update_conversation(conversation_id, conversation=Body(...), session=Depends(my_cxo_db_conn.get_db_sess)) async

Updates a conversation's metadata, such as user_id, name, summary, created_by, modified_by, and modified_at fields.

Parameters:

Name	Type	Description	Default
conversation_id	int	ID of the conversation to update.	required
conversation	ConversationUpdate	Updated conversation data.	Body(...)
session	AsyncSession	The database session.	Depends(get_db_sess)

Returns:

Name	Type	Description
Conversation		The updated conversation.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

@conversation_router.put("/{conversation_id}", response_model=Conversation)
async def update_conversation(conversation_id: int, conversation: ConversationUpdate = Body(...), session: AsyncSession = Depends(my_cxo_db_conn.get_db_sess)):
	"""
	Updates a conversation's metadata, such as user_id, name, summary,
	created_by, modified_by, and modified_at fields.

	Args:
	    conversation_id (int): ID of the conversation to update.
	    conversation (ConversationUpdate): Updated conversation data.
	    session (AsyncSession): The database session.

	Returns:
	    Conversation: The updated conversation.
	"""
	try:
		# Fetch the conversation by its ID
		result = await session.execute(select(ConversationModel).where(ConversationModel.conversation_id == conversation_id))
		conversation_model = result.scalar_one_or_none()

		# If the conversation is not found, raise an error
		if conversation_model is None:
			raise HTTPException(status_code=404, detail="Conversation not found")

		# Only update fields that are provided in the request (ignore None values)
		if conversation.user_id is not None:
			conversation_model.user_id = conversation.user_id

		if conversation.name is not None:
			conversation_model.name = conversation.name

		if conversation.summary is not None:
			conversation_model.summary = conversation.summary

		if conversation.created_by is not None:
			conversation_model.created_by = conversation.created_by

		if conversation.modified_by is not None:
			conversation_model.modified_by = conversation.modified_by

		# Update the modified_at field to the current datetime
		conversation_model.modified_at = datetime.utcnow()

		# Commit the changes and refresh the conversation model
		await session.commit()
		await session.refresh(conversation_model)

		# Return the updated conversation in the Pydantic model format
		return conversation_model_to_pydantic(conversation_model)

	except SQLAlchemyError as e:
		await session.rollback()
		logging.exception("Error updating conversation")
		raise HTTPException(status_code=500, detail=str(e))

update_message(conversation_id, message_id, message=Body(...), session=Depends(my_cxo_db_conn.get_db_sess)) async

Updates an existing message within a conversation.

Parameters:

Name	Type	Description	Default
conversation_id	int	ID of the conversation the message belongs to.	required
message_id	int	ID of the message to update.	required
message	MessageUpdate	Updated message data.	Body(...)
session	AsyncSession	The database session.	Depends(get_db_sess)

Returns:

Name	Type	Description
Message		The updated message.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

@conversation_router.put("/{conversation_id}/messages/{message_id}/", response_model=Message)
async def update_message(conversation_id: int, message_id: int, message: MessageUpdate = Body(...), session: AsyncSession = Depends(my_cxo_db_conn.get_db_sess)):
	"""
	Updates an existing message within a conversation.

	Args:
	    conversation_id (int): ID of the conversation the message belongs to.
	    message_id (int): ID of the message to update.
	    message (MessageUpdate): Updated message data.
	    session (AsyncSession): The database session.

	Returns:
	    Message: The updated message.
	"""
	try:
		# Fetch the message and eagerly load the conversation relationship
		result = await session.execute(
			select(MessageModel).options(selectinload(MessageModel.conversation)).where(MessageModel.conversation_id == conversation_id).where(MessageModel.message_id == message_id)
		)
		message_model = result.scalar_one_or_none()

		if not message_model:
			raise HTTPException(status_code=404, detail="Message not found")

		# Update the message fields if provided
		if message.content is not None:
			message_model.content = message.content
		if message.parent_message_id is not None:
			message_model.parent_message_id = message.parent_message_id

		# Update the conversation metadata
		conversation_model = message_model.conversation
		conversation_model.modified_at = datetime.utcnow()
		conversation_model.modified_by = message_model.created_by

		# Commit the changes
		await session.commit()
		await session.refresh(message_model)

		return message_model

	except SQLAlchemyError as e:
		await session.rollback()
		logging.exception("Error updating message")
		raise HTTPException(status_code=500, detail=str(e))

update_message_flag(conversation_id, message_id, message_flag_id, flag_update, session=Depends(my_cxo_db_conn.get_db_sess)) async

Updates an existing message flag for a specific message within a conversation.

This method allows users to update the flag type, comment, or both for an existing message flag. It first ensures that the conversation, message, and flag exist, then applies the updates.

Parameters:

Name	Type	Description	Default
conversation_id	int	ID of the conversation that contains the message.	required
message_id	int	ID of the message to which the flag is associated.	required
message_flag_id	int	ID of the message flag to update.	required
flag_update	MessageFlagUpdate	Pydantic model containing the new flag type, comment, or both.	required
session	AsyncSession	The SQLAlchemy async session for database interaction.	Depends(get_db_sess)

Returns:

Name	Type	Description
MessageFlag		The updated message flag object.

Raises:

Type	Description
HTTPException	If the conversation, message, or flag cannot be found, or if a database error occurs.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

@conversation_router.put(
	"/{conversation_id}/messages/{message_id}/flags/{message_flag_id}/",
	response_model=MessageFlag,
	status_code=200,
	summary="Update a message flag",
	description="Update the flag type or comment for a specific message flag within a conversation.",
)
async def update_message_flag(conversation_id: int, message_id: int, message_flag_id: int, flag_update: MessageFlagUpdate, session: AsyncSession = Depends(my_cxo_db_conn.get_db_sess)):
	"""
	Updates an existing message flag for a specific message within a conversation.

	This method allows users to update the flag type, comment, or both for an existing message flag.
	It first ensures that the conversation, message, and flag exist, then applies the updates.

	Args:
	    conversation_id (int): ID of the conversation that contains the message.
	    message_id (int): ID of the message to which the flag is associated.
	    message_flag_id (int): ID of the message flag to update.
	    flag_update (MessageFlagUpdate): Pydantic model containing the new flag type, comment, or both.
	    session (AsyncSession): The SQLAlchemy async session for database interaction.

	Returns:
	    MessageFlag: The updated message flag object.

	Raises:
	    HTTPException: If the conversation, message, or flag cannot be found, or if a database error occurs.
	"""
	try:
		# Step 1: Ensure the conversation exists in the database
		result = await session.execute(select(ConversationModel).where(ConversationModel.conversation_id == conversation_id))
		conversation = result.scalar_one_or_none()

		if not conversation:
			raise HTTPException(status_code=404, detail="Conversation not found")

		# Step 2: Ensure the message exists in the conversation
		result = await session.execute(select(MessageModel).where(MessageModel.message_id == message_id, MessageModel.conversation_id == conversation_id))
		message = result.scalar_one_or_none()

		if not message:
			raise HTTPException(status_code=404, detail="Message not found in the specified conversation")

		# Step 3: Ensure the flag exists
		result = await session.execute(select(MessageFlagModel).where(MessageFlagModel.message_flag_id == message_flag_id, MessageFlagModel.message_id == message_id))
		message_flag = result.scalar_one_or_none()

		if not message_flag:
			raise HTTPException(status_code=404, detail="Message flag not found")

		# Step 4: Update the flag's fields if provided
		if flag_update.flag is not None:
			message_flag.flag = flag_update.flag

		if flag_update.comment is not None:
			message_flag.comment = flag_update.comment

		if flag_update.created_by is not None:
			message_flag.created_by = flag_update.created_by

		# Commit the updates and refresh the flag instance
		await session.commit()
		await session.refresh(message_flag)

		# Step 5: Return the updated message flag as a response
		return MessageFlag(
			message_flag_id=message_flag.message_flag_id,
			message_id=message_flag.message_id,
			flag=message_flag.flag,
			comment=message_flag.comment,
			created_at=message_flag.created_at,
			created_by=message_flag.created_by,
		)

	except SQLAlchemyError:
		# Rollback in case of an error during the transaction
		await session.rollback()
		logging.exception("Error while updating the message flag")
		raise HTTPException(status_code=500, detail="Internal server error")

update_message_sql(conversation_id, message_id, message_sql_id, message_sql_data, session=Depends(my_cxo_db_conn.get_db_sess)) async

Updates the SQL query and results for a specific message SQL entry within a conversation.

This method first ensures that the conversation, message, and message SQL entry exist. Then, it updates the provided fields (SQL query and results) for the message SQL entry.

Parameters:

Name	Type	Description	Default
conversation_id	int	ID of the conversation that contains the message.	required
message_id	int	ID of the message for which the SQL query and results are to be updated.	required
message_sql_id	int	ID of the message SQL entry to update.	required
message_sql_data	MessageSQLUpdate	Pydantic model containing the updated SQL query and/or results.	required
session	AsyncSession	The SQLAlchemy async session for database interaction.	Depends(get_db_sess)

Returns:

Name	Type	Description
MessageSQL		The updated MessageSQL object containing the updated query and results.

Raises:

Type	Description
HTTPException	If the conversation, message, or message SQL entry cannot be found, or if a database error occurs.

Source code in mycxo/boxtalk/routes/api/conversations/conversation_route.py

@conversation_router.put(
	"/{conversation_id}/messages/{message_id}/sql/{message_sql_id}/",
	response_model=MessageSQL,
	status_code=200,
	summary="Update SQL entry for a message",
	description="Update the SQL query and results for a specific message SQL entry.",
)
async def update_message_sql(conversation_id: int, message_id: int, message_sql_id: int, message_sql_data: MessageSQLUpdate, session: AsyncSession = Depends(my_cxo_db_conn.get_db_sess)):
	"""
	Updates the SQL query and results for a specific message SQL entry within a conversation.

	This method first ensures that the conversation, message, and message SQL entry exist. Then, it updates
	the provided fields (SQL query and results) for the message SQL entry.

	Args:
	    conversation_id (int): ID of the conversation that contains the message.
	    message_id (int): ID of the message for which the SQL query and results are to be updated.
	    message_sql_id (int): ID of the message SQL entry to update.
	    message_sql_data (MessageSQLUpdate): Pydantic model containing the updated SQL query and/or results.
	    session (AsyncSession): The SQLAlchemy async session for database interaction.

	Returns:
	    MessageSQL: The updated MessageSQL object containing the updated query and results.

	Raises:
	    HTTPException: If the conversation, message, or message SQL entry cannot be found, or if a database error occurs.
	"""
	try:
		# Step 1: Ensure the conversation exists in the database
		result = await session.execute(select(ConversationModel).where(ConversationModel.conversation_id == conversation_id))
		conversation = result.scalar_one_or_none()

		if not conversation:
			raise HTTPException(status_code=404, detail="Conversation not found")

		# Step 2: Ensure the message exists in the conversation
		result = await session.execute(select(MessageModel).where(MessageModel.message_id == message_id, MessageModel.conversation_id == conversation_id))
		message = result.scalar_one_or_none()

		if not message:
			raise HTTPException(status_code=404, detail="Message not found in the specified conversation")

		# Step 3: Ensure the message SQL entry exists
		result = await session.execute(select(MessageSQLModel).where(MessageSQLModel.message_sql_id == message_sql_id, MessageSQLModel.message_id == message_id))
		message_sql = result.scalar_one_or_none()

		if not message_sql:
			raise HTTPException(status_code=404, detail="Message SQL entry not found")

		# Step 4: Update the SQL query and results if provided
		if message_sql_data.sql_query is not None:
			message_sql.query_generated = message_sql_data.sql_query

		if message_sql_data.sql_results is not None:
			# Convert sql_results to string if it's a list
			message_sql.query_results = json.dumps(message_sql_data.sql_results) if isinstance(message_sql_data.sql_results, list) else message_sql_data.sql_results

		# Step 5: Commit the updates and refresh the SQL entry
		await session.commit()
		await session.refresh(message_sql)

		# Step 6: Return the updated SQL entry
		return MessageSQL(
			message_sql_id=message_sql.message_sql_id,
			message_id=message_sql.message_id,
			query_generated=message_sql.query_generated,
			query_results=message_sql.query_results,
			created_at=message_sql.created_at,
		)

	except SQLAlchemyError:
		# Rollback in case of any failure during the transaction
		await session.rollback()
		logging.exception("Error while updating SQL entry for the message")
		raise HTTPException(status_code=500, detail="Internal server error")