Release v0.2.8: Add support for model reasoning/thinking content

- Added reasoning support for GLM-4 (reasoning_content)
- Added reasoning support for OpenRouter models (reasoning field)
- Added 'Reasoning' panel in REPL to display thinking process
- Updated logging to capture reasoning data
- Updated parser to handle multi-format reasoning fields
- Bump version to 0.2.8

Author: Mage212

README.md

@@ -1,6 +1,6 @@
 # 🤖 SuperCoder
 
-[![Version](https://img.shields.io/badge/version-0.2.7-blue.svg)](https://github.com/Mage212/supercoder)
+[![Version](https://img.shields.io/badge/version-0.2.8-blue.svg)](https://github.com/Mage212/supercoder)
 [![Python](https://img.shields.io/badge/python-3.11+-green.svg)](https://python.org)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "supercoder"
-version = "0.2.6"
+version = "0.2.8"
 description = "AI Coding Assistant for the Terminal"
 readme = "README.md"
 requires-python = ">=3.11"

supercoder/agent/coder_agent.py

@@ -189,6 +189,7 @@ def chat_stream(self, user_message: str):
 
         # Stream response
         response_text = ""
+        reasoning_text = ""
 
         try:
             for chunk in self.llm.chat_stream(messages):
@@ -197,9 +198,15 @@ def chat_stream(self, user_message: str):
                     raise AgentAbortedError("Agent execution aborted by user")
 
                 if not chunk.is_done:
+                    # Yield reasoning if present
+                    if chunk.reasoning:
+                        yield {"type": "reasoning", "content": chunk.reasoning}
+                        reasoning_text += chunk.reasoning
+                        
                     # Yield token for real-time display
-                    yield {"type": "token", "content": chunk.content}
-                    response_text += chunk.content
+                    if chunk.content:
+                        yield {"type": "token", "content": chunk.content}
+                        response_text += chunk.content
 
             # Signal end of text generation
             yield {"type": "done", "content": ""}
@@ -226,7 +233,7 @@ def chat_stream(self, user_message: str):
         if response_text:
             self.context.add_message(Message("assistant", response_text))
             # Log model response
-            get_logger().log_model_response(response_text, self.llm.model)
+            get_logger().log_model_response(response_text, self.llm.model, reasoning=reasoning_text)
             # Auto-save session
             self._save_current_session()
 

supercoder/llm/base.py

@@ -16,6 +16,7 @@ class Message:
 class StreamChunk:
     """Streaming response chunk."""
     content: str
+    reasoning: str = ""  # reasoning_content from models like GLM
     is_done: bool = False
 
 

supercoder/llm/openai_client.py

@@ -77,8 +77,14 @@ def chat_stream(self, messages: list[Message]) -> Iterator[StreamChunk]:
             )
 
             for chunk in stream:
-                if chunk.choices and chunk.choices[0].delta.content:
-                    yield StreamChunk(content=chunk.choices[0].delta.content)
+                if chunk.choices:
+                    delta = chunk.choices[0].delta
+                    content = delta.content or ""
+                    # Check for reasoning_content (GLM, DeepSeek, etc.) or just reasoning (OpenRouter)
+                    reasoning = getattr(delta, "reasoning_content", "") or getattr(delta, "reasoning", "") or ""
+                    
+                    if content or reasoning:
+                        yield StreamChunk(content=content, reasoning=reasoning)
 
             yield StreamChunk(content="", is_done=True)
 

supercoder/logging.py

@@ -52,16 +52,22 @@ def log_user_input(self, message: str) -> None:
             "timestamp": datetime.now().isoformat(),
         })
 
-    def log_model_response(self, response: str, model: Optional[str] = None) -> None:
+    def log_model_response(self, response: str, model: Optional[str] = None, reasoning: Optional[str] = None) -> None:
         """Log model response."""
         if not self.enabled:
             return
-        self._write_entry({
+        
+        entry = {
             "type": "assistant",
             "model": model or self.model_name,
             "content": response,
             "timestamp": datetime.now().isoformat(),
-        })
+        }
+        
+        if reasoning:
+            entry["reasoning"] = reasoning
+            
+        self._write_entry(entry)
 
     def log_system_prompt(self, prompt: str) -> None:
         """Log the current system prompt."""

supercoder/repl.py

@@ -158,6 +158,7 @@ def _handle_chat(self, message):
 
         # Collect full response first, then display
         response_text = ""
+        reasoning_text = ""
         tool_calls = []
         tool_results = []
         errors = []
@@ -181,6 +182,8 @@ def _handle_chat(self, message):
 
                     if event_type == "token":
                         response_text += content
+                    elif event_type == "reasoning":
+                        reasoning_text += content
                     elif event_type == "tool_call":
                         tool_calls.append(content)
                         # Track files from tool args
@@ -238,6 +241,15 @@ def _handle_chat(self, message):
         for error in errors:
             self.console.print(Panel(f"[red]{error}[/]", title="[bold red]Error[/]", border_style="red"))
 
+        # 2.5 Display Reasoning (New)
+        if reasoning_text:
+            self.console.print(Panel(
+                Markdown(reasoning_text),
+                title="[bold magenta]💭 Reasoning[/]",
+                border_style="magenta",
+                box=self._get_box_style()
+            ))
+
         # 3. Display Assistant Response
         clean_text = self._filter_special_tokens(response_text)
         if clean_text:

tests/test_reasoning_extraction.py

@@ -0,0 +1,68 @@
+
+import pytest
+from unittest.mock import MagicMock, Mock
+from supercoder.llm.openai_client import OpenAIClient
+from supercoder.llm.base import Message, StreamChunk
+from supercoder.config import Config
+
+class MockDelta:
+    def __init__(self, content=None, reasoning_content=None):
+        self.content = content
+        if reasoning_content is not None:
+            self.reasoning_content = reasoning_content
+
+class MockChoice:
+    def __init__(self, delta):
+        self.delta = delta
+
+class MockChunk:
+    def __init__(self, choices=None):
+        self.choices = choices
+
+def test_chat_stream_extracts_reasoning():
+    """Test that chat_stream extracts reasoning_content correctly."""
+    
+    # Setup mock config
+    config = Config()
+    config.api_key = "test_key"
+    
+    # Setup mock client
+    client = OpenAIClient(config)
+    client.client = MagicMock()
+    
+    # Mock streaming response
+    # 1. Chunk with reasoning only
+    # 2. Chunk with content only
+    # 3. Chunk with both
+    mock_chunks = [
+        MockChunk(choices=[MockChoice(delta=MockDelta(content=None, reasoning_content="Thinking..."))]),
+        MockChunk(choices=[MockChoice(delta=MockDelta(content="Hello", reasoning_content=None))]),
+        MockChunk(choices=[MockChoice(delta=MockDelta(content=" World", reasoning_content=" (Done)"))]),
+    ]
+    
+    client.client.chat.completions.create.return_value = mock_chunks
+    
+    # Run chat_stream
+    chunks = list(client.chat_stream([Message("user", "test")]))
+    
+    # Verify chunks (ignoring the last "is_done" chunk)
+    assert len(chunks) == 4  # 3 data chunks + 1 done chunk
+    
+    # Chunk 1: Reasoning only
+    assert chunks[0].content == "" 
+    assert chunks[0].reasoning == "Thinking..."
+    
+    # Chunk 2: Content only
+    assert chunks[1].content == "Hello"
+    assert chunks[1].reasoning == ""
+    
+    # Chunk 3: Both
+    assert chunks[2].content == " World"
+    assert chunks[2].reasoning == " (Done)"
+    
+    # Chunk 4: Done
+    assert chunks[3].is_done is True
+
+if __name__ == "__main__":
+    test_chat_stream_extracts_reasoning()
+    print("Test passed!")