feat(conversation): store reasoning separately from content, add show/hide UI

- Add Message.reasoning field; content holds only the final response
- Add content_utils with START_BLOCK_REASONING, END_REASONING, split_reasoning_and_content
- DB: add reasoning column (migration 003), save/load, backward compat for legacy ```think...```
- Anthropic, DeepSeek: populate reasoning and content separately; streaming yields ("reasoning", chunk) or ("content", chunk)
- Completion handler: route structured chunks, wrap streaming reasoning with `<think>`, parse legacy format after stream
- Display: show reasoning when checkbox on, using `<think>` tags
- Config: default in Preferences, per-tab override in conversation panel (always visible)
- API: send only content

Author: AAClause

basilisk/completion_handler.py

@@ -16,6 +16,11 @@
 import wx
 
 from basilisk import global_vars
+from basilisk.conversation.content_utils import (
+	END_REASONING,
+	START_BLOCK_REASONING,
+	split_reasoning_and_content,
+)
 from basilisk.conversation.conversation_model import (
 	Conversation,
 	Message,
@@ -80,6 +85,7 @@ def __init__(
 		self._last_completed_block: Optional[MessageBlock] = None
 		self.last_time = 0
 		self.stream_buffer: str = ""
+		self._stream_reasoning_started: bool = False
 
 	@ensure_no_task_running
 	def start_completion(
@@ -184,6 +190,28 @@ def _handle_stream_chunk(
 				if not message_block.response.citations:
 					message_block.response.citations = []
 				message_block.response.citations.append(chunk_data)
+			elif chunk_type == "reasoning":
+				message_block.response.reasoning = (
+					message_block.response.reasoning or ""
+				) + chunk_data
+				if not self._stream_reasoning_started:
+					self._stream_reasoning_started = True
+					wx.CallAfter(
+						self._handle_stream_buffer,
+						f"{START_BLOCK_REASONING}\n{chunk_data}",
+					)
+				else:
+					wx.CallAfter(self._handle_stream_buffer, chunk_data)
+			elif chunk_type == "content":
+				message_block.response.content += chunk_data
+				if self._stream_reasoning_started:
+					self._stream_reasoning_started = False
+					wx.CallAfter(
+						self._handle_stream_buffer,
+						f"\n{END_REASONING}\n\n{chunk_data}",
+					)
+				else:
+					wx.CallAfter(self._handle_stream_buffer, chunk_data)
 			else:
 				logger.warning(
 					"Unknown chunk type in streaming response: %s", chunk_type
@@ -199,6 +227,20 @@ def flush_stream_buffer(self, message_block: MessageBlock) -> None:
 			wx.CallAfter(self._handle_stream_buffer, self.stream_buffer)
 			self.stream_buffer = ""
 
+	def _split_reasoning_from_content(
+		self, message_block: MessageBlock
+	) -> None:
+		"""Parse legacy ```think...``` format into reasoning and content."""
+		if not message_block.response:
+			return
+		reasoning, content = split_reasoning_and_content(
+			message_block.response.content
+		)
+		if reasoning is not None:
+			message_block.response = message_block.response.model_copy(
+				update={"reasoning": reasoning, "content": content}
+			)
+
 	def _handle_streaming_completion(
 		self,
 		engine: BaseEngine,
@@ -219,7 +261,10 @@ def _handle_streaming_completion(
 		Returns:
 			True if streaming was handled successfully, False if stopped
 		"""
-		new_block.response = Message(role=MessageRoleEnum.ASSISTANT, content="")
+		new_block.response = Message(
+			role=MessageRoleEnum.ASSISTANT, content="", reasoning=None
+		)
+		self._stream_reasoning_started = False
 
 		# Notify that streaming has started
 		if self.on_stream_start:
@@ -233,6 +278,10 @@ def _handle_streaming_completion(
 
 		# Notify that streaming has finished
 		self.flush_stream_buffer(new_block)
+		if self._stream_reasoning_started:
+			wx.CallAfter(self._handle_stream_buffer, f"\n{END_REASONING}\n\n")
+		# Parse legacy ```think...``` format into reasoning + content
+		self._split_reasoning_from_content(new_block)
 		if self.on_stream_finish:
 			wx.CallAfter(self.on_stream_finish, new_block)
 		return True

basilisk/config/main_config.py

@@ -49,6 +49,7 @@ class ConversationSettings(BaseModel):
 	auto_save_draft: bool = Field(default=True)
 	reopen_last_conversation: bool = Field(default=False)
 	last_active_conversation_id: int | None = Field(default=None)
+	show_reasoning_blocks: bool = Field(default=True)
 
 
 class ImagesSettings(BaseModel):

basilisk/conversation/content_utils.py

@@ -0,0 +1,32 @@
+"""Utilities for message content processing."""
+
+from __future__ import annotations
+
+import re
+
+START_BLOCK_REASONING = "<think>"
+END_REASONING = "</think>"
+
+_THINK_BLOCK_PATTERN = re.compile(r"```think\s*\n(.*?)\n```\s*", re.DOTALL)
+
+
+def split_reasoning_and_content(text: str) -> tuple[str | None, str]:
+	"""Split content into reasoning and official response.
+
+	Handles legacy format where reasoning was concatenated as ```think...```
+	before the response. Used when loading from DB or after streaming.
+
+	Args:
+		text: Content that may contain ```think...``` block.
+
+	Returns:
+		Tuple of (reasoning, content). If no think block, returns (None, text).
+	"""
+	if not text:
+		return None, text or ""
+	match = _THINK_BLOCK_PATTERN.search(text)
+	if not match:
+		return None, text
+	reasoning = match.group(1).strip()
+	content = (_THINK_BLOCK_PATTERN.sub("", text) or "").strip()
+	return reasoning or None, content

basilisk/conversation/conversation_model.py

@@ -64,6 +64,7 @@ class BaseMessage(BaseModel):
 class Message(BaseMessage):
 	"""Represents a message in a conversation. The message may contain text content and optional attachments."""
 
+	reasoning: str | None = Field(default=None)
 	attachments: list[AttachmentFile | ImageFile] | None = Field(default=None)
 	citations: list[dict[str, Any]] | None = Field(default=None)
 	audio_data: str | None = Field(default=None)

basilisk/conversation/database/manager.py

@@ -17,6 +17,7 @@
 	AttachmentFileTypes,
 	ImageFile,
 )
+from basilisk.conversation.content_utils import split_reasoning_and_content
 from basilisk.conversation.conversation_model import (
 	Conversation,
 	Message,
@@ -234,6 +235,7 @@ def _save_message(
 			message_block_id=block_id,
 			role=role,
 			content=message.content,
+			reasoning=getattr(message, "reasoning", None),
 			audio_data=getattr(message, "audio_data", None),
 			audio_format=getattr(message, "audio_format", None),
 		)
@@ -740,56 +742,72 @@ def load_conversation(self, conv_id: int) -> Conversation:
 				version=BSKC_VERSION,
 			)
 
+	def _load_message_attachments(
+		self, db_msg: DBMessage
+	) -> list[AttachmentFile | ImageFile] | None:
+		"""Load attachments from a DB message."""
+		if not db_msg.attachment_links:
+			return None
+		attachments = []
+		for link in sorted(db_msg.attachment_links, key=lambda x: x.position):
+			attachment = self._load_attachment(
+				link.attachment, link.description
+			)
+			if attachment:
+				attachments.append(attachment)
+		return attachments or None
+
+	def _load_message_citations(self, db_msg: DBMessage) -> list[dict] | None:
+		"""Load citations from a DB message."""
+		if not db_msg.citations:
+			return None
+		citations = []
+		for db_cit in sorted(db_msg.citations, key=lambda x: x.position):
+			citation = {}
+			if db_cit.cited_text is not None:
+				citation["cited_text"] = db_cit.cited_text
+			if db_cit.source_title is not None:
+				citation["source_title"] = db_cit.source_title
+			if db_cit.source_url is not None:
+				citation["source_url"] = db_cit.source_url
+			if db_cit.start_index is not None:
+				citation["start_index"] = db_cit.start_index
+			if db_cit.end_index is not None:
+				citation["end_index"] = db_cit.end_index
+			citations.append(citation)
+		return citations
+
+	def _resolve_reasoning_and_content(
+		self, reasoning: str | None, content: str
+	) -> tuple[str | None, str]:
+		"""Resolve reasoning and content, parsing legacy format if needed."""
+		if reasoning is not None or not content:
+			return reasoning, content
+		parsed_reasoning, parsed_content = split_reasoning_and_content(content)
+		if parsed_reasoning is not None:
+			return parsed_reasoning, parsed_content
+		return reasoning, content
+
 	def _load_message(self, db_msg: DBMessage) -> Message:
 		"""Convert a DB message to a Pydantic message."""
 		role = (
 			MessageRoleEnum.USER
 			if db_msg.role == "user"
 			else MessageRoleEnum.ASSISTANT
 		)
-
-		# Load attachments
-		attachments = None
-		if db_msg.attachment_links:
-			attachments = []
-			sorted_links = sorted(
-				db_msg.attachment_links, key=lambda x: x.position
-			)
-			for link in sorted_links:
-				db_att = link.attachment
-				attachment = self._load_attachment(db_att, link.description)
-				if attachment:
-					attachments.append(attachment)
-
-		# Load citations
-		citations = None
-		if db_msg.citations:
-			citations = []
-			sorted_cites = sorted(db_msg.citations, key=lambda x: x.position)
-			for db_cit in sorted_cites:
-				citation = {}
-				if db_cit.cited_text is not None:
-					citation["cited_text"] = db_cit.cited_text
-				if db_cit.source_title is not None:
-					citation["source_title"] = db_cit.source_title
-				if db_cit.source_url is not None:
-					citation["source_url"] = db_cit.source_url
-				if db_cit.start_index is not None:
-					citation["start_index"] = db_cit.start_index
-				if db_cit.end_index is not None:
-					citation["end_index"] = db_cit.end_index
-				citations.append(citation)
-
-		audio_data = getattr(db_msg, "audio_data", None)
-		audio_format = getattr(db_msg, "audio_format", None)
-
+		attachments = self._load_message_attachments(db_msg)
+		citations = self._load_message_citations(db_msg)
+		reasoning, content = self._resolve_reasoning_and_content(
+			getattr(db_msg, "reasoning", None), db_msg.content
+		)
 		return Message(
 			role=role,
-			content=db_msg.content,
-			attachments=attachments or None,
-			citations=citations or None,
-			audio_data=audio_data,
-			audio_format=audio_format,
+			content=content,
+			reasoning=reasoning,
+			attachments=attachments,
+			citations=citations,
+			audio_data=getattr(db_msg, "audio_data", None),
+			audio_format=getattr(db_msg, "audio_format", None),
 		)
 
 	@staticmethod

basilisk/conversation/database/models.py

@@ -133,6 +133,7 @@ class DBMessage(Base):
 	)
 	role: Mapped[str]
 	content: Mapped[str]
+	reasoning: Mapped[str | None] = mapped_column(default=None)
 	audio_data: Mapped[str | None] = mapped_column(default=None)
 	audio_format: Mapped[str | None] = mapped_column(default=None)
 

basilisk/presenters/conversation_presenter.py

@@ -260,7 +260,11 @@ def _on_stream_start(
 	):
 		"""Called when streaming starts."""
 		self.conversation.add_block(new_block, system_message)
-		self.view.messages.display_new_block(new_block, streaming=True)
+		self.view.messages.display_new_block(
+			new_block,
+			streaming=True,
+			show_reasoning_blocks=self.view.get_effective_show_reasoning_blocks(),
+		)
 		self.view.messages.SetInsertionPointEnd()
 
 	@_guard_destroying
@@ -276,7 +280,10 @@ def _on_non_stream_finish(
 	):
 		"""Called when non-streaming completion finishes."""
 		self.conversation.add_block(new_block, system_message)
-		self.view.messages.display_new_block(new_block)
+		self.view.messages.display_new_block(
+			new_block,
+			show_reasoning_blocks=self.view.get_effective_show_reasoning_blocks(),
+		)
 		audio_data = getattr(new_block.response, "audio_data", None)
 		if audio_data:
 			from basilisk.audio_utils import play_audio_from_base64

basilisk/presenters/preferences_presenter.py

@@ -108,6 +108,9 @@ def on_ok(self) -> None:
 		conf.conversation.reopen_last_conversation = (
 			self.view.reopen_last_conversation.GetValue()
 		)
+		conf.conversation.show_reasoning_blocks = (
+			self.view.show_reasoning_blocks.GetValue()
+		)
 		conf.images.resize = self.view.image_resize.GetValue()
 		conf.images.max_height = int(self.view.image_max_height.GetValue())
 		conf.images.max_width = int(self.view.image_max_width.GetValue())