gptdiff 0.1.28__tar.gz → 0.1.31__tar.gz

{gptdiff-0.1.28 → gptdiff-0.1.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: gptdiff
-Version: 0.1.28
+Version: 0.1.31
 Summary: A tool to generate and apply git diffs using LLMs
 Author: 255labs
 Classifier: License :: OSI Approved :: MIT License
@@ -31,30 +31,48 @@ GPTDiff: Create and apply diffs using AI.
 This tool leverages natural language instructions to modify project codebases.
 -->
 
+## Table of Contents
+
+- [Quick Start](#quick-start)
+- [Example Usage](#example-usage-of-gptdiff)
+- [Basic Usage](#basic-usage)
+- [Simple Command Line Agent Loops](#simple-command-line-agent-loops)
+- [Why Choose GPTDiff?](#why-choose-gptdiff)
+- [Core Capabilities](#core-capabilities)
+  - [CLI Excellence](#-cli-excellence)
+  - [Magic Diff Generation](#-magic-diff-generation)
+  - [Smart Apply System](#-smart-apply-system)
+- [Get Started](#get-started)
+  - [Installation](#installation)
+  - [Configuration](#configuration)
+- [Command Line Usage](#command-line-usage)
+
 🚀 **Create and apply diffs with AI**  
 Modify your project using plain English.
 
-More documentation at [gptdiff.255labs.xyz](gptdiff.255labs.xyz)
+More documentation at [gptdiff.255labs.xyz](https://gptdiff.255labs.xyz)
+
+## Quick Start
 
+1. **Install GPTDiff**
+   
+   
 ### Example Usage of `gptdiff`
 
 #### Apply a Patch Directly
-```
-bash
+```bash
 gptdiff "Add button animations on press" --apply
 ```
 ✅ Successfully applied patch
 
 #### Generate a Patch File
-```
-bash
+```bash
 gptdiff "Add API documentation" --call
 ```
 🔧 Patch written to `diff.patch`
 
 #### Generate a Prompt File Without Calling LLM
-```
-bash
+```bash
 gptdiff "Improve error messages"
 ```
 📄 LLM not called, written to `prompt.txt`

{gptdiff-0.1.28 → gptdiff-0.1.31}/README.md

@@ -4,30 +4,48 @@ GPTDiff: Create and apply diffs using AI.
 This tool leverages natural language instructions to modify project codebases.
 -->
 
+## Table of Contents
+
+- [Quick Start](#quick-start)
+- [Example Usage](#example-usage-of-gptdiff)
+- [Basic Usage](#basic-usage)
+- [Simple Command Line Agent Loops](#simple-command-line-agent-loops)
+- [Why Choose GPTDiff?](#why-choose-gptdiff)
+- [Core Capabilities](#core-capabilities)
+  - [CLI Excellence](#-cli-excellence)
+  - [Magic Diff Generation](#-magic-diff-generation)
+  - [Smart Apply System](#-smart-apply-system)
+- [Get Started](#get-started)
+  - [Installation](#installation)
+  - [Configuration](#configuration)
+- [Command Line Usage](#command-line-usage)
+
 🚀 **Create and apply diffs with AI**  
 Modify your project using plain English.
 
-More documentation at [gptdiff.255labs.xyz](gptdiff.255labs.xyz)
+More documentation at [gptdiff.255labs.xyz](https://gptdiff.255labs.xyz)
+
+## Quick Start
 
+1. **Install GPTDiff**
+   
+   
 ### Example Usage of `gptdiff`
 
 #### Apply a Patch Directly
-```
-bash
+```bash
 gptdiff "Add button animations on press" --apply
 ```
 ✅ Successfully applied patch
 
 #### Generate a Patch File
-```
-bash
+```bash
 gptdiff "Add API documentation" --call
 ```
 🔧 Patch written to `diff.patch`
 
 #### Generate a Prompt File Without Calling LLM
-```
-bash
+```bash
 gptdiff "Improve error messages"
 ```
 📄 LLM not called, written to `prompt.txt`
@@ -301,4 +319,4 @@ pip install -e .[test]
 pytest tests/
 ```
 
-This will execute all unit tests verifying core diff generation and application logic.
+This will execute all unit tests verifying core diff generation and application logic.

{gptdiff-0.1.28 → gptdiff-0.1.31}/gptdiff/applydiff.py

@@ -7,6 +7,7 @@ Contains the function to apply unified git diffs to files on disk.
 from pathlib import Path
 import re
 import hashlib
+from collections import defaultdict
 
 def apply_diff(project_dir, diff_text):
     """
@@ -191,6 +192,12 @@ def parse_diff_per_file(diff_text):
         Uses 'b/' prefix detection from git diffs to determine target paths
         This doesn't work all the time and needs to be revised with stronger models
     """
+    def dedup_diffs(diffs):
+        groups = defaultdict(list)
+        for key, value in diffs:
+            groups[key].append(value)
+        return [[key, "\n".join(values)] for key, values in groups.items()]
+
     header_re = re.compile(r'^(?:diff --git\s+)?(a/[^ ]+)\s+(b/[^ ]+)\s*$', re.MULTILINE)
     lines = diff_text.splitlines()
 
@@ -227,7 +234,7 @@ def parse_diff_per_file(diff_text):
             if deletion_mode and not any(l.startswith("+++ ") for l in current_lines):
                 current_lines.append("+++ /dev/null")
             diffs.append((current_file, "\n".join(current_lines)))
-        return diffs
+        return dedup_diffs(diffs)
     else:
         # Use header-based strategy.
         diffs = []
@@ -260,6 +267,6 @@ def parse_diff_per_file(diff_text):
             if deletion_mode and not any(l.startswith("+++ ") for l in current_lines):
                 current_lines.append("+++ /dev/null")
             diffs.append((current_file, "\n".join(current_lines)))
-        return diffs
+        return dedup_diffs(diffs)
 
 

{gptdiff-0.1.28 → gptdiff-0.1.31}/gptdiff/gptdiff.py

@@ -20,6 +20,7 @@ from threading import Lock
 import openai
 from openai import OpenAI
 import tiktoken
+import requests
 import time
 import os
 import json
@@ -35,13 +36,14 @@ from ai_agent_toolbox import MarkdownParser, MarkdownPromptFormatter, Toolbox, F
 from .applydiff import apply_diff, parse_diff_per_file
 
 VERBOSE = False
-diff_context = contextvars.ContextVar('diffcontent', default="")
+diff_context = contextvars.ContextVar('diffcontent', default=[])
 
 def create_diff_toolbox():
     toolbox = Toolbox()
+    diff_context.set([])
     
     def diff(content: str):
-        diff_context.set(content)
+        diff_context.set(diff_context.get()+[content])
         return content
 
     toolbox.add_tool(
@@ -218,7 +220,105 @@ def domain_for_url(base_url):
         domain = base_url
     return domain
 
-def call_llm_for_diff(system_prompt, user_prompt, files_content, model, temperature=0.7, max_tokens=30000, api_key=None, base_url=None):
+def call_llm(api_key, base_url, model, messages, max_tokens, temperature, budget_tokens=None):
+    # Check if we're using Anthropic
+    if "api.anthropic.com" in base_url:
+        anthropic_url = "https://api.anthropic.com/v1/messages"
+        
+        headers = {
+            "x-api-key": api_key,
+            "Content-Type": "application/json",
+            "anthropic-version": "2023-06-01"
+        }
+        
+        # Extract system message if present
+        system_message = None
+        filtered_messages = []
+        
+        for message in messages:
+            if message["role"] == "system":
+                system_message = message["content"]
+            else:
+                filtered_messages.append(message)
+        
+        # Prepare request data
+        data = {
+            "model": model,
+            "messages": filtered_messages,
+            "max_tokens": max_tokens,
+            "temperature": temperature
+        }
+        
+        # Add system message as top-level parameter if found
+        if system_message:
+            data["system"] = system_message
+
+        if budget_tokens:
+            data["temperature"] = 1
+            data["thinking"] = {"budget_tokens": budget_tokens, "type": "enabled"}
+        
+        # Make the API call
+        response = requests.post(anthropic_url, headers=headers, json=data)
+        response_data = response.json()
+        
+        if 'error' in response_data:
+            print(f"Error from Anthropic API: {response_data}")
+            return response_data
+        
+        # Format response to match OpenAI structure for compatibility
+        class OpenAICompatResponse:
+            class Choice:
+                class Message:
+                    def __init__(self, content):
+                        self.content = content
+                
+                def __init__(self, message):
+                    self.message = message
+            
+            class Usage:
+                def __init__(self, prompt_tokens, completion_tokens, total_tokens):
+                    self.prompt_tokens = prompt_tokens
+                    self.completion_tokens = completion_tokens
+                    self.total_tokens = total_tokens
+            
+            def __init__(self, choices, usage):
+                self.choices = choices
+                self.usage = usage
+        
+        # Get content from the response
+        thinking_items = [item["thinking"] for item in response_data["content"] if item["type"] == "thinking"]
+        text_items = [item["text"] for item in response_data["content"] if item["type"] == "text"]
+        if not text_items:
+            raise ValueError("No 'text' type found in response content")
+        text_content = text_items[0]
+        if thinking_items:
+            wrapped_thinking = f"<think>{thinking_items[0]}</think>"
+            message_content = wrapped_thinking + "\n" + text_content
+        else:
+            message_content = text_content
+        
+        # Extract token usage information
+        input_tokens = response_data["usage"]["input_tokens"]
+        output_tokens = response_data["usage"]["output_tokens"]
+        total_tokens = input_tokens + output_tokens
+        
+        # Create the response object with usage information
+        message = OpenAICompatResponse.Choice.Message(message_content)
+        choice = OpenAICompatResponse.Choice(message)
+        usage = OpenAICompatResponse.Usage(input_tokens, output_tokens, total_tokens)
+        
+        return OpenAICompatResponse([choice], usage)
+    else:
+        # Use OpenAI client as before
+        client = OpenAI(api_key=api_key, base_url=base_url)
+        return client.chat.completions.create(
+            model=model,
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature
+        )
+
+def call_llm_for_diff(system_prompt, user_prompt, files_content, model, temperature=1.0, max_tokens=30000, api_key=None, base_url=None, budget_tokens=None):
     enc = tiktoken.get_encoding("o200k_base")
     
     # Use colors in print statements
@@ -258,13 +358,16 @@ def call_llm_for_diff(system_prompt, user_prompt, files_content, model, temperat
     if not base_url:
         base_url = os.getenv('GPTDIFF_LLM_BASE_URL', "https://nano-gpt.com/api/v1/")
     base_url = base_url or "https://nano-gpt.com/api/v1/"
-    
-    client = OpenAI(api_key=api_key, base_url=base_url)
-    response = client.chat.completions.create(model=model,
+
+    response = call_llm(
+        api_key=api_key,
+        base_url=base_url,
+        model=model,
         messages=messages,
         max_tokens=max_tokens,
-        temperature=temperature)
-
+        budget_tokens=budget_tokens,
+        temperature=temperature
+    )
     if VERBOSE:
         print("Debug: Raw LLM Response\n---")
         print(response.choices[0].message.content.strip())
@@ -294,7 +397,7 @@ def call_llm_for_diff(system_prompt, user_prompt, files_content, model, temperat
         toolbox.use(event)
     diff_response = diff_context.get()
 
-    return full_response, diff_response, prompt_tokens, completion_tokens, total_tokens
+    return full_response, "\n".join(diff_response), prompt_tokens, completion_tokens, total_tokens
 
 # New API functions
 def build_environment(files_dict):
@@ -306,7 +409,7 @@ def build_environment(files_dict):
         env.append(content)
     return '\n'.join(env)
 
-def generate_diff(environment, goal, model=None, temperature=0.7, max_tokens=32000, api_key=None, base_url=None, prepend=None):
+def generate_diff(environment, goal, model=None, temperature=1.0, max_tokens=32000, api_key=None, base_url=None, prepend=None, anthropic_budget_tokens=None):
     """API: Generate a git diff from the environment and goal.
 
 If 'prepend' is provided, it should be a path to a file whose content will be
@@ -314,6 +417,10 @@ prepended to the system prompt.
     """
     if model is None:
         model = os.getenv('GPTDIFF_MODEL', 'deepseek-reasoner')
+        # Use ANTHROPIC_BUDGET_TOKENS env var if set and no cli override provided
+        if anthropic_budget_tokens is None:
+            anthropic_budget_tokens = os.getenv('ANTHROPIC_BUDGET_TOKENS')
+    
     if prepend:
         if prepend.startswith("http://") or prepend.startswith("https://"):
             import urllib.request
@@ -326,15 +433,16 @@ prepended to the system prompt.
     
     diff_tag = "```diff"
     system_prompt = prepend + f"Output a git diff into a \"{diff_tag}\" block."
-    _, diff_text, _, _, _, _ = call_llm_for_diff(
+    _, diff_text, _, _, _ = call_llm_for_diff(
         system_prompt, 
         goal, 
         environment, 
-        model=model,
+        model,
+        temperature=temperature,
+        max_tokens=max_tokens,
         api_key=api_key,
         base_url=base_url,
-        max_tokens=max_tokens,
-        temperature=temperature
+        budget_tokens=int(anthropic_budget_tokens) if anthropic_budget_tokens is not None else None
     )
     return diff_text
 
@@ -416,11 +524,12 @@ def parse_arguments():
     parser.add_argument('--call', action='store_true',
                         help='Call the GPT-4 API. Writes the full prompt to prompt.txt if not specified.')
     parser.add_argument('files', nargs='*', default=[], help='Specify additional files or directories to include.')
-    parser.add_argument('--temperature', type=float, default=0.7, help='Temperature parameter for model creativity (0.0 to 2.0)')
+    parser.add_argument('--temperature', type=float, default=1.0, help='Temperature parameter for model creativity (0.0 to 2.0)')
     parser.add_argument('--max_tokens', type=int, default=30000, help='Temperature parameter for model creativity (0.0 to 2.0)')
     parser.add_argument('--model', type=str, default=None, help='Model to use for the API call.')
     parser.add_argument('--applymodel', type=str, default=None, help='Model to use for applying the diff. Defaults to the value of --model if not specified.')
     parser.add_argument('--nowarn', action='store_true', help='Disable large token warning')
+    parser.add_argument('--anthropic_budget_tokens', type=int, default=None, help='Budget tokens for Anthropic extended thinking')
     parser.add_argument('--verbose', action='store_true', help='Enable verbose output with detailed information')
     return parser.parse_args()
 
@@ -768,20 +877,13 @@ def main():
             if confirmation != 'y':
                 print("Request canceled")
                 sys.exit(0)
-        try:
-            full_text, diff_text, prompt_tokens, completion_tokens, total_tokens = call_llm_for_diff(system_prompt, user_prompt, files_content, args.model, 
-                                                                                                    temperature=args.temperature,
-                                                                                                    api_key=os.getenv('GPTDIFF_LLM_API_KEY'),
-                                                                                                    base_url=os.getenv('GPTDIFF_LLM_BASE_URL', "https://nano-gpt.com/api/v1/"),
-                                                                                                    max_tokens=args.max_tokens
-                                                                                                    ) 
-        except Exception as e:
-            full_text = f"{e}"
-            diff_text = ""
-            prompt_tokens = 0
-            completion_tokens = 0
-            total_tokens = 0
-            print(f"Error in LLM response {e}")
+        full_text, diff_text, prompt_tokens, completion_tokens, total_tokens = call_llm_for_diff(system_prompt, user_prompt, files_content, args.model, 
+                                                                                                temperature=args.temperature,
+                                                                                                api_key=os.getenv('GPTDIFF_LLM_API_KEY'),
+                                                                                                base_url=os.getenv('GPTDIFF_LLM_BASE_URL', "https://nano-gpt.com/api/v1/"),
+                                                                                                max_tokens=args.max_tokens,
+                                                                                                budget_tokens=args.anthropic_budget_tokens
+                                                                                                ) 
 
     if(diff_text.strip() == ""):
         print(f"\033[1;33mWarning: No valid diff data was generated. This could be due to an unclear prompt or an invalid LLM response.\033[0m")
@@ -831,20 +933,17 @@ def swallow_reasoning(full_response: str) -> (str, str):
         r"(?P<reasoning>>\s*Reasoning.*?Reasoned.*?seconds)",
         re.DOTALL
     )
-    match = pattern.search(full_response)
-    if match:
+    reasoning_list = []
+    def replacer(match):
         raw_reasoning = match.group("reasoning")
-        # Remove any leading '+' characters and extra whitespace from each line
         reasoning_lines = [line.lstrip('+').strip() for line in raw_reasoning.splitlines()]
         reasoning = "\n".join(reasoning_lines).strip()
-
-        # Remove the reasoning block from the response using its exact span
-        final_content = full_response[:match.start()] + full_response[match.end():]
-        final_content = final_content.strip()
-    else:
-        reasoning = ""
-        final_content = full_response.strip()
-    return final_content, reasoning
+        reasoning_list.append(reasoning)
+        return ""
+    
+    final_content = re.sub(pattern, replacer, full_response)
+    reasoning = "\n".join(reasoning_list)
+    return final_content.strip(), reasoning
 
 def strip_bad_output(updated: str, original: str) -> str:
     """

{gptdiff-0.1.28 → gptdiff-0.1.31}/gptdiff.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: gptdiff
-Version: 0.1.28
+Version: 0.1.31
 Summary: A tool to generate and apply git diffs using LLMs
 Author: 255labs
 Classifier: License :: OSI Approved :: MIT License
@@ -31,30 +31,48 @@ GPTDiff: Create and apply diffs using AI.
 This tool leverages natural language instructions to modify project codebases.
 -->
 
+## Table of Contents
+
+- [Quick Start](#quick-start)
+- [Example Usage](#example-usage-of-gptdiff)
+- [Basic Usage](#basic-usage)
+- [Simple Command Line Agent Loops](#simple-command-line-agent-loops)
+- [Why Choose GPTDiff?](#why-choose-gptdiff)
+- [Core Capabilities](#core-capabilities)
+  - [CLI Excellence](#-cli-excellence)
+  - [Magic Diff Generation](#-magic-diff-generation)
+  - [Smart Apply System](#-smart-apply-system)
+- [Get Started](#get-started)
+  - [Installation](#installation)
+  - [Configuration](#configuration)
+- [Command Line Usage](#command-line-usage)
+
 🚀 **Create and apply diffs with AI**  
 Modify your project using plain English.
 
-More documentation at [gptdiff.255labs.xyz](gptdiff.255labs.xyz)
+More documentation at [gptdiff.255labs.xyz](https://gptdiff.255labs.xyz)
+
+## Quick Start
 
+1. **Install GPTDiff**
+   
+   
 ### Example Usage of `gptdiff`
 
 #### Apply a Patch Directly
-```
-bash
+```bash
 gptdiff "Add button animations on press" --apply
 ```
 ✅ Successfully applied patch
 
 #### Generate a Patch File
-```
-bash
+```bash
 gptdiff "Add API documentation" --call
 ```
 🔧 Patch written to `diff.patch`
 
 #### Generate a Prompt File Without Calling LLM
-```
-bash
+```bash
 gptdiff "Improve error messages"
 ```
 📄 LLM not called, written to `prompt.txt`

{gptdiff-0.1.28 → gptdiff-0.1.31}/gptdiff.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ tests/test_applydiff.py
 tests/test_applydiff_edgecases.py
 tests/test_diff_parse.py
 tests/test_failing_case.py
+tests/test_multidiff.py
 tests/test_parse_diff_per_file.py
 tests/test_smartapply.py
 tests/test_strip_bad_ouput.py

{gptdiff-0.1.28 → gptdiff-0.1.31}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='gptdiff',
-    version='0.1.28',
+    version='0.1.31',
     description='A tool to generate and apply git diffs using LLMs',
     author='255labs',
     packages=find_packages(),  # Use find_packages() to automatically discover packages

gptdiff-0.1.31/tests/test_multidiff.py

@@ -0,0 +1,50 @@
+import pytest
+from gptdiff.gptdiff import generate_diff
+
+# Dummy classes to simulate an LLM response
+class DummyMessage:
+    def __init__(self, content):
+        self.content = content
+
+class DummyChoice:
+    def __init__(self, content):
+        self.message = DummyMessage(content)
+
+class DummyUsage:
+    def __init__(self, prompt_tokens, completion_tokens, total_tokens):
+        self.prompt_tokens = prompt_tokens
+        self.completion_tokens = completion_tokens
+        self.total_tokens = total_tokens
+
+class DummyResponse:
+    def __init__(self, content, prompt_tokens, completion_tokens, total_tokens):
+        self.choices = [DummyChoice(content)]
+        self.usage = DummyUsage(prompt_tokens, completion_tokens, total_tokens)
+
+def test_fail_diff_through_call_llm(monkeypatch):
+    diff_str = """```diff
+DIFF 1
+```
+
+Some text here
+```diff
+DIFF 2
+```"""
+
+    expected = """
+DIFF 1
+
+DIFF 2"""
+
+ 
+    # Define a dummy call_llm function that returns our fake response
+    def dummy_call_llm(api_key, base_url, model, messages, max_tokens, budget_tokens, temperature):
+        return DummyResponse(diff_str, prompt_tokens=10, completion_tokens=20, total_tokens=30)
+
+    # Patch call_llm in the gptdiff module with our dummy function.
+    monkeypatch.setattr("gptdiff.gptdiff.call_llm", dummy_call_llm)
+
+    # generate_diff calls call_llm_for_diff internally, which now uses our dummy_call_llm.
+    result = generate_diff("dummy environment", "dummy goal", model="test-model")
+
+    assert result.strip() == expected.strip()

{gptdiff-0.1.28 → gptdiff-0.1.31}/tests/test_parse_diff_per_file.py

@@ -126,6 +126,34 @@ diff --git a/file2.py b/file2.py
         self.assertIn("file1.py", paths)
         self.assertIn("file2.py", paths)
 
+
+    def test_multiple_files(self):
+        diff_text = """diff --git a/file1.py b/file1.py
+--- a/file1.py
++++ b/file1.py
+@@ -1 +1 @@
+-print("Hello")
++print("Hi")
+diff --git a/file2.py b/file2.py
+--- a/file2.py
++++ b/file2.py
+@@ -1 +1 @@
+-print("World")
++print("Earth")
+diff --git a/file1.py b/file1.py
+--- a/file1.py
++++ b/file1.py
+@@ -3 +3 @@
+-print("Hello2")
++print("Hi2")
+"""
+        result = parse_diff_per_file(diff_text)
+        self.assertEqual(len(result), 2)
+        paths = [fp for fp, _ in result]
+        self.assertIn("file1.py", paths)
+        self.assertIn("file2.py", paths)
+        assert("Hi2" in result[0][1])
+
 def test_parse_diff_per_file_unconventional_header():
     diff_text = """--- game.js
 +++ game.js

{gptdiff-0.1.28 → gptdiff-0.1.31}/tests/test_swallow_reasoning.py

@@ -2,7 +2,7 @@ import pytest
 
 from gptdiff.gptdiff import swallow_reasoning
 
-def test_swallow_reasoning_extraction():
+def test_swallow_reasoning_extraction_simple():
     llm_response = (
         "+> Reasoning\n"
         "+None\n"
@@ -13,19 +13,39 @@ def test_swallow_reasoning_extraction():
     final_content, reasoning = swallow_reasoning(llm_response)
     expected_reasoning = (
         "> Reasoning\n"
-        "**Applying the diff**\n"
-        "I'm piecing together how to efficiently apply a diff to a file...\n"
-        "**Returning the result**\n"
-        "I'm finalizing the method to apply the diff updates...\n"
-        "Reasoned for 6 seconds"
+        "None\n"
+        "Reasoned about summary drawer button 변경 for 15 seconds"
     )
     assert reasoning == expected_reasoning
     # The final content should no longer contain the reasoning block.
     assert expected_reasoning not in final_content
-    # And it should contain the diff block.
-    assert "```diff" in final_content
 
 
+def test_swallow_reasoning_extraction_multiline():
+    llm_response = (
+        "line 1> Reasoning\n"
+        "+None\n"
+        "+Reasoned about summary drawer button 변경 for 1 seconds\n"
+        "line 2\n"
+        "  > Reasoning\n"
+        "+None\n"
+        "+Reasoned about summary drawer button 변경 for 2 seconds\n"
+        "line 3:"
+    )
+    final_content, reasoning = swallow_reasoning(llm_response)
+    expected_reasoning = (
+        "> Reasoning\n"
+        "None\n"
+        "Reasoned about summary drawer button 변경 for 1 seconds\n"
+        "> Reasoning\n"
+        "None\n"
+        "Reasoned about summary drawer button 변경 for 2 seconds"
+    )
+    assert reasoning == expected_reasoning
+    assert "line 1\nline 2\n  \nline 3:" == final_content
+    # The final content should no longer contain the reasoning block.
+    assert expected_reasoning not in final_content
+
 def test_swallow_reasoning_with_untested_response():
     llm_response = (
         "> Reasoning\n"