klaude-code 2.5.2__tar.gz → 2.5.3__tar.gz

{klaude_code-2.5.2 → klaude_code-2.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.5.2
+Version: 2.5.3
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0

{klaude_code-2.5.2 → klaude_code-2.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "2.5.2"
+version = "2.5.3"
 description = "Minimal code agent CLI"
 readme = "README.md"
 requires-python = ">=3.13,<3.14"

{klaude_code-2.5.2 → klaude_code-2.5.3}/src/klaude_code/cli/auth_cmd.py

@@ -4,20 +4,9 @@ import datetime
 import webbrowser
 
 import typer
-from prompt_toolkit.styles import Style
 
 from klaude_code.log import log
-from klaude_code.tui.terminal.selector import SelectItem, select_one
-
-_SELECT_STYLE = Style(
-    [
-        ("instruction", "ansibrightblack"),
-        ("pointer", "ansigreen"),
-        ("highlighted", "ansigreen"),
-        ("text", "ansibrightblack"),
-        ("question", "bold"),
-    ]
-)
+from klaude_code.tui.terminal.selector import DEFAULT_PICKER_STYLE, SelectItem, select_one
 
 
 def _select_provider() -> str | None:
@@ -30,7 +19,7 @@ def _select_provider() -> str | None:
         message="Select provider to login:",
         items=items,
         pointer="→",
-        style=_SELECT_STYLE,
+        style=DEFAULT_PICKER_STYLE,
         use_search_filter=False,
     )
 

{klaude_code-2.5.2 → klaude_code-2.5.3}/src/klaude_code/cli/cost_cmd.py

@@ -183,14 +183,14 @@ def render_cost_table(daily_stats: dict[str, DailyStats]) -> Table:
         box=ASCII_HORIZONAL,
     )
 
-    table.add_column("Date", style="cyan", no_wrap=True)
-    table.add_column("Model", no_wrap=True)
-    table.add_column("Input", justify="right", no_wrap=True)
-    table.add_column("Output", justify="right", no_wrap=True)
-    table.add_column("Cache", justify="right", no_wrap=True)
-    table.add_column("Total", justify="right", no_wrap=True)
-    table.add_column("USD", justify="right", no_wrap=True)
-    table.add_column("CNY", justify="right", no_wrap=True)
+    table.add_column("Date", style="cyan")
+    table.add_column("Model", overflow="ellipsis")
+    table.add_column("Input", justify="right")
+    table.add_column("Output", justify="right")
+    table.add_column("Cache", justify="right")
+    table.add_column("Total", justify="right")
+    table.add_column("USD", justify="right")
+    table.add_column("CNY", justify="right")
 
     # Sort dates
     sorted_dates = sorted(daily_stats.keys())
@@ -222,7 +222,7 @@ def render_cost_table(daily_stats: dict[str, DailyStats]) -> Table:
 
             table.add_row(
                 format_date_display(date_str) if first_row else "",
-                f"- {model_name}",
+                f"{model_name}",
                 format_tokens(stats.input_tokens),
                 format_tokens(stats.output_tokens),
                 format_tokens(stats.cached_tokens),
@@ -276,7 +276,7 @@ def render_cost_table(daily_stats: dict[str, DailyStats]) -> Table:
         usd_str, cny_str = format_cost_dual(stats.cost_usd, stats.cost_cny)
         table.add_row(
             "",
-            f"- {model_name}",
+            f"{model_name}",
             format_tokens(stats.input_tokens),
             format_tokens(stats.output_tokens),
             format_tokens(stats.cached_tokens),

{klaude_code-2.5.2 → klaude_code-2.5.3}/src/klaude_code/cli/main.py

@@ -13,13 +13,46 @@ from klaude_code.session import Session
 from klaude_code.tui.command.resume_cmd import select_session_sync
 from klaude_code.ui.terminal.title import update_terminal_title
 
-ENV_HELP = """\
-Environment Variables:
-
-  KLAUDE_READ_GLOBAL_LINE_CAP  Max lines to read (default: 2000)
-
-  KLAUDE_READ_MAX_CHARS        Max total chars to read (default: 50000)
-"""
+ENV_HELP_LINES = [
+    "Environment Variables:",
+    "",
+    "Provider API keys (built-in config):",
+    "  ANTHROPIC_API_KEY             Anthropic API key",
+    "  OPENAI_API_KEY                OpenAI API key",
+    "  OPENROUTER_API_KEY            OpenRouter API key",
+    "  GOOGLE_API_KEY                Google API key (Gemini)",
+    "  DEEPSEEK_API_KEY              DeepSeek API key",
+    "  MOONSHOT_API_KEY              Moonshot API key (Kimi)",
+    "",
+    "AWS credentials (Bedrock):",
+    "  AWS_ACCESS_KEY_ID             AWS access key id",
+    "  AWS_SECRET_ACCESS_KEY         AWS secret access key",
+    "  AWS_REGION                    AWS region",
+    "",
+    "Tool limits (Read):",
+    "  KLAUDE_READ_GLOBAL_LINE_CAP    Max lines to read (default: 2000)",
+    "  KLAUDE_READ_MAX_CHARS          Max total chars to read (default: 50000)",
+    "  KLAUDE_READ_MAX_IMAGE_BYTES    Max image bytes to read (default: 4MB)",
+    "  KLAUDE_IMAGE_OUTPUT_MAX_BYTES  Max decoded image bytes (default: 64MB)",
+    "",
+    "Notifications / testing:",
+    "  KLAUDE_NOTIFY                 Set to 0/off/false/disable(d) to disable task notifications",
+    "  KLAUDE_TEST_SIGNAL            In tmux, emit `tmux wait-for -S <channel>` on task completion",
+    "  TMUX                          Auto-detected; required for KLAUDE_TEST_SIGNAL",
+    "",
+    "Editor / terminal integration:",
+    "  EDITOR                        Preferred editor for `klaude config`",
+    "  TERM                          Terminal identification (auto-detected)",
+    "  TERM_PROGRAM                  Terminal identification (auto-detected)",
+    "  WT_SESSION                    Terminal hint (auto-detected)",
+    "  VTE_VERSION                   Terminal hint (auto-detected)",
+    "  GHOSTTY_RESOURCES_DIR         Ghostty detection (auto-detected)",
+    "",
+    "Compatibility:",
+    "  ANTHROPIC_AUTH_TOKEN          Reserved by anthropic SDK; temporarily unset during client init",
+]
+
+ENV_HELP = "\n\n".join(ENV_HELP_LINES)
 
 app = typer.Typer(
     add_completion=False,

{klaude_code-2.5.2 → klaude_code-2.5.3}/src/klaude_code/cli/session_cmd.py

@@ -9,9 +9,7 @@ from klaude_code.session import Session
 def _session_confirm(sessions: list[Session.SessionMetaBrief], message: str) -> bool:
     """Show session list and confirm deletion using prompt_toolkit."""
 
-    from prompt_toolkit.styles import Style
-
-    from klaude_code.tui.terminal.selector import SelectItem, select_one
+    from klaude_code.tui.terminal.selector import DEFAULT_PICKER_STYLE, SelectItem, select_one
 
     def _fmt(ts: float) -> str:
         try:
@@ -37,14 +35,7 @@ def _session_confirm(sessions: list[Session.SessionMetaBrief], message: str) ->
         message=message,
         items=items,
         pointer="→",
-        style=Style(
-            [
-                ("question", "bold"),
-                ("pointer", "ansigreen"),
-                ("highlighted", "ansigreen"),
-                ("text", ""),
-            ]
-        ),
+        style=DEFAULT_PICKER_STYLE,
         use_search_filter=False,
     )
     return bool(result)

{klaude_code-2.5.2 → klaude_code-2.5.3}/src/klaude_code/config/assets/builtin_config.yaml

@@ -1,4 +1,3 @@
----
 # Built-in provider and model configurations
 # Users can start using klaude by simply setting environment variables
 # (ANTHROPIC_API_KEY, OPENAI_API_KEY, etc.) without manual configuration.
@@ -25,32 +24,58 @@ provider_list:
   protocol: responses
   api_key: ${OPENAI_API_KEY}
   model_list:
-  - model_name: gpt-5.2
+  - model_name: gpt-5.2-high
     model_id: gpt-5.2
     max_tokens: 128000
     context_limit: 400000
     verbosity: high
     thinking:
       reasoning_effort: high
+      reasoning_summary: detailed
+    cost: {input: 1.75, output: 14, cache_read: 0.17}
+  - model_name: gpt-5.2-medium
+    model_id: gpt-5.2
+    context_limit: 400000
+    verbosity: high
+    thinking:
+      reasoning_effort: medium
+      reasoning_summary: concise
+    cost: {input: 1.75, output: 14, cache_read: 0.17}
+  - model_name: gpt-5.2-low
+    model_id: gpt-5.2
+    context_limit: 400000
+    verbosity: low
+    thinking:
+      reasoning_effort: low
+      reasoning_summary: concise
+    cost: {input: 1.75, output: 14, cache_read: 0.17}
+  - model_name: gpt-5.2-fast
+    model_id: gpt-5.2
+    context_limit: 400000
+    verbosity: low
+    thinking:
+      reasoning_effort: none
     cost: {input: 1.75, output: 14, cache_read: 0.17}
-- provider_name: openrouter
-  protocol: openrouter
-  api_key: ${OPENROUTER_API_KEY}
-  model_list:
   - model_name: gpt-5.1-codex-max
-    model_id: openai/gpt-5.1-codex-max
+    model_id: gpt-5.1-codex-max
     max_tokens: 128000
     context_limit: 400000
     thinking:
       reasoning_effort: medium
+      reasoning_summary: detailed
     cost: {input: 1.25, output: 10, cache_read: 0.13}
-  - model_name: gpt-5.2
+- provider_name: openrouter
+  protocol: openrouter
+  api_key: ${OPENROUTER_API_KEY}
+  model_list:
+  - model_name: gpt-5.2-high
     model_id: openai/gpt-5.2
     max_tokens: 128000
     context_limit: 400000
     verbosity: high
     thinking:
       reasoning_effort: high
+      reasoning_summary: detailed
     cost: {input: 1.75, output: 14, cache_read: 0.17}
   - model_name: gpt-5.2-medium
     model_id: openai/gpt-5.2
@@ -59,22 +84,7 @@ provider_list:
     verbosity: high
     thinking:
       reasoning_effort: medium
-    cost: {input: 1.75, output: 14, cache_read: 0.17}
-  - model_name: gpt-5.2-low
-    model_id: openai/gpt-5.2
-    max_tokens: 128000
-    context_limit: 400000
-    verbosity: low
-    thinking:
-      reasoning_effort: low
-    cost: {input: 1.75, output: 14, cache_read: 0.17}
-  - model_name: gpt-5.2-fast
-    model_id: openai/gpt-5.2
-    max_tokens: 128000
-    context_limit: 400000
-    verbosity: low
-    thinking:
-      reasoning_effort: none
+      reasoning_summary: concise
     cost: {input: 1.75, output: 14, cache_read: 0.17}
   - model_name: kimi
     model_id: moonshotai/kimi-k2-thinking
@@ -165,10 +175,14 @@ provider_list:
   - model_name: gemini-pro
     model_id: gemini-3-pro-preview
     context_limit: 1048576
+    thinking:
+      reasoning_effort: high
     cost: {input: 2, output: 12, cache_read: 0.2}
   - model_name: gemini-flash
     model_id: gemini-3-flash-preview
     context_limit: 1048576
+    thinking:
+      reasoning_effort: medium
     cost: {input: 0.5, output: 3, cache_read: 0.05}
   - model_name: nano-banana-pro
     model_id: gemini-3-pro-image-preview
@@ -177,6 +191,13 @@ provider_list:
     - image
     - text
     cost: {input: 2, output: 12, cache_read: 0.2, image: 120}
+  - model_name: nano-banana
+    model_id: gemini-2.5-flash-image
+    context_limit: 33000
+    modalities:
+    - image
+    - text
+    cost: {input: 0.3, output: 2.5, cache_read: 0.03, image: 30}
 - provider_name: bedrock
   protocol: bedrock
   aws_access_key: ${AWS_ACCESS_KEY_ID}

{klaude_code-2.5.2 → klaude_code-2.5.3}/src/klaude_code/config/model_matcher.py

@@ -102,6 +102,7 @@ def match_model_from_config(preferred: str | None = None) -> ModelMatchResult:
             )
 
         # Normalized matching (e.g. gpt52 == gpt-5.2, gpt52 in gpt-5.2-2025-...)
+        # Only match selector/model_name exactly; model_id is checked via substring match below
         preferred_norm = _normalize_model_key(preferred)
         normalized_matches: list[ModelEntry] = []
         if preferred_norm:
@@ -110,7 +111,6 @@ def match_model_from_config(preferred: str | None = None) -> ModelMatchResult:
                 for m in models
                 if preferred_norm == _normalize_model_key(m.selector)
                 or preferred_norm == _normalize_model_key(m.model_name)
-                or preferred_norm == _normalize_model_key(m.model_id or "")
             ]
             if len(normalized_matches) == 1:
                 return ModelMatchResult(

{klaude_code-2.5.2 → klaude_code-2.5.3}/src/klaude_code/const.py

@@ -27,6 +27,7 @@ def _get_int_env(name: str, default: int) -> int:
 # =============================================================================
 
 MAX_FAILED_TURN_RETRIES = 10  # Maximum retry attempts for failed turns
+RETRY_PRESERVE_PARTIAL_MESSAGE = True  # Preserve partial message on stream error for retry prefill
 LLM_HTTP_TIMEOUT_TOTAL = 300.0  # HTTP timeout for LLM API requests (seconds)
 LLM_HTTP_TIMEOUT_CONNECT = 15.0  # HTTP connect timeout (seconds)
 LLM_HTTP_TIMEOUT_READ = 285.0  # HTTP read timeout (seconds)
@@ -157,7 +158,7 @@ MARKDOWN_RIGHT_MARGIN = 2  # Right margin (columns) for markdown rendering
 STATUS_HINT_TEXT = " (esc to interrupt)"  # Status hint text shown after spinner
 
 # Spinner status texts
-STATUS_WAITING_TEXT = "Connecting …"
+STATUS_WAITING_TEXT = "Loading …"
 STATUS_THINKING_TEXT = "Thinking …"
 STATUS_COMPOSING_TEXT = "Composing"
 

{klaude_code-2.5.2 → klaude_code-2.5.3}/src/klaude_code/core/tool/file/edit_tool.py

@@ -98,7 +98,7 @@ class EditTool(ToolABC):
         if is_directory(file_path):
             return message.ToolResultMessage(
                 status="error",
-                output_text="<tool_use_error>Illegal operation on a directory. edit</tool_use_error>",
+                output_text="<tool_use_error>Illegal operation on a directory: edit</tool_use_error>",
             )
 
         if args.old_string == "":

{klaude_code-2.5.2 → klaude_code-2.5.3}/src/klaude_code/core/tool/file/read_tool.py

@@ -210,7 +210,7 @@ class ReadTool(ToolABC):
         if is_directory(file_path):
             return message.ToolResultMessage(
                 status="error",
-                output_text="<tool_use_error>Illegal operation on a directory. read</tool_use_error>",
+                output_text="<tool_use_error>Illegal operation on a directory: read</tool_use_error>",
             )
         if not file_exists(file_path):
             return message.ToolResultMessage(
@@ -308,7 +308,7 @@ class ReadTool(ToolABC):
         except IsADirectoryError:
             return message.ToolResultMessage(
                 status="error",
-                output_text="<tool_use_error>Illegal operation on a directory. read</tool_use_error>",
+                output_text="<tool_use_error>Illegal operation on a directory: read</tool_use_error>",
             )
 
         if offset > max(read_result.total_lines, 0):

{klaude_code-2.5.2 → klaude_code-2.5.3}/src/klaude_code/core/tool/file/write_tool.py

@@ -57,7 +57,7 @@ class WriteTool(ToolABC):
         if is_directory(file_path):
             return message.ToolResultMessage(
                 status="error",
-                output_text="<tool_use_error>Illegal operation on a directory. write</tool_use_error>",
+                output_text="<tool_use_error>Illegal operation on a directory: write</tool_use_error>",
             )
 
         file_tracker = context.file_tracker

{klaude_code-2.5.2 → klaude_code-2.5.3}/src/klaude_code/core/turn.py

@@ -4,7 +4,7 @@ from collections.abc import AsyncGenerator
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
-from klaude_code.const import SUPPORTED_IMAGE_SIZES
+from klaude_code.const import RETRY_PRESERVE_PARTIAL_MESSAGE, SUPPORTED_IMAGE_SIZES
 from klaude_code.core.tool import ToolABC
 from klaude_code.core.tool.context import SubAgentResumeClaims, ToolContext
 
@@ -24,6 +24,12 @@ from klaude_code.llm.client import LLMStreamABC
 from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import events, llm_param, message, model, tools
 
+# Protocols that support prefill (continuing from partial assistant message)
+_PREFILL_SUPPORTED_PROTOCOLS = frozenset({
+    "anthropic",
+    "claude_oauth",
+})
+
 
 class TurnError(Exception):
     """Raised when a turn fails and should be retried."""
@@ -176,6 +182,18 @@ class TurnExecutor:
             yield event
 
         if self._turn_result.stream_error is not None:
+            # Save accumulated content for potential prefill on retry (only for supported protocols)
+            protocol = ctx.llm_client.get_llm_config().protocol
+            supports_prefill = protocol.value in _PREFILL_SUPPORTED_PROTOCOLS
+            if (
+                RETRY_PRESERVE_PARTIAL_MESSAGE
+                and supports_prefill
+                and self._turn_result.assistant_message is not None
+                and self._turn_result.assistant_message.parts
+            ):
+                session_ctx.append_history([self._turn_result.assistant_message])
+                # Add continuation prompt to avoid Anthropic thinking block requirement
+                session_ctx.append_history([message.UserMessage(parts=[message.TextPart(text="continue")])])
             session_ctx.append_history([self._turn_result.stream_error])
             yield events.TurnEndEvent(session_id=session_ctx.session_id)
             raise TurnError(self._turn_result.stream_error.error)

{klaude_code-2.5.2 → klaude_code-2.5.3}/src/klaude_code/llm/anthropic/client.py

@@ -33,8 +33,13 @@ from klaude_code.const import (
 from klaude_code.llm.anthropic.input import convert_history_to_input, convert_system_to_input, convert_tool_schema
 from klaude_code.llm.client import LLMClientABC, LLMStreamABC
 from klaude_code.llm.input_common import apply_config_defaults
-from klaude_code.llm.partial_message import degrade_thinking_to_text
 from klaude_code.llm.registry import register
+from klaude_code.llm.stream_parts import (
+    append_text_part,
+    append_thinking_text_part,
+    build_partial_message,
+    build_partial_parts,
+)
 from klaude_code.llm.usage import MetadataTracker, error_llm_stream
 from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import llm_param, message, model
@@ -64,11 +69,10 @@ class AnthropicStreamStateManager:
 
     def __init__(self, model_id: str) -> None:
         self.model_id = model_id
-        self.accumulated_thinking: list[str] = []
-        self.accumulated_content: list[str] = []
-        self.parts: list[message.Part] = []
+        self.assistant_parts: list[message.Part] = []
         self.response_id: str | None = None
-        self.pending_signature: str | None = None
+        self._pending_signature: str | None = None
+        self._pending_signature_thinking_index: int | None = None
         self.stop_reason: model.StopReason | None = None
 
         # Tool call state
@@ -80,34 +84,59 @@ class AnthropicStreamStateManager:
         self.input_token: int = 0
         self.cached_token: int = 0
 
-    def flush_thinking(self) -> None:
-        """Flush accumulated thinking content into parts."""
-        if not self.accumulated_thinking:
+    def append_thinking_text(self, text: str) -> None:
+        """Append thinking text, merging with the previous ThinkingTextPart when possible."""
+        index = append_thinking_text_part(self.assistant_parts, text, model_id=self.model_id)
+        if index is not None:
+            self._pending_signature_thinking_index = index
+
+    def append_text(self, text: str) -> None:
+        """Append assistant text, merging with the previous TextPart when possible."""
+        append_text_part(self.assistant_parts, text)
+
+    def set_pending_signature(self, signature: str) -> None:
+        if signature:
+            self._pending_signature = signature
+
+    def flush_pending_signature(self) -> None:
+        """Attach any pending signature to the most recent thinking segment.
+
+        Anthropic's signature is semantically tied to its thinking content. The
+        signature delta may arrive slightly after thinking text, so we insert the
+        signature part adjacent to the thinking part it signs.
+        """
+
+        if not self._pending_signature:
+            return
+        if self._pending_signature_thinking_index is None:
+            # No thinking part seen for this signature; drop it.
+            self._pending_signature = None
             return
-        full_thinking = "".join(self.accumulated_thinking)
-        self.parts.append(message.ThinkingTextPart(text=full_thinking, model_id=self.model_id))
-        if self.pending_signature:
-            self.parts.append(
-                message.ThinkingSignaturePart(
-                    signature=self.pending_signature,
-                    model_id=self.model_id,
-                    format="anthropic",
-                )
-            )
-        self.accumulated_thinking.clear()
-        self.pending_signature = None
 
-    def flush_content(self) -> None:
-        """Flush accumulated content into parts."""
-        if not self.accumulated_content:
+        insert_at = self._pending_signature_thinking_index + 1
+        # Avoid inserting duplicates if flush is called multiple times.
+        if insert_at < len(self.assistant_parts) and isinstance(
+            self.assistant_parts[insert_at], message.ThinkingSignaturePart
+        ):
+            self._pending_signature = None
             return
-        self.parts.append(message.TextPart(text="".join(self.accumulated_content)))
-        self.accumulated_content.clear()
+
+        self.assistant_parts.insert(
+            insert_at,
+            message.ThinkingSignaturePart(
+                signature=self._pending_signature,
+                model_id=self.model_id,
+                format="anthropic",
+            ),
+        )
+
+        self._pending_signature = None
+        self._pending_signature_thinking_index = None
 
     def flush_tool_call(self) -> None:
         """Flush current tool call into parts."""
         if self.current_tool_name and self.current_tool_call_id:
-            self.parts.append(
+            self.assistant_parts.append(
                 message.ToolCallPart(
                     call_id=self.current_tool_call_id,
                     tool_name=self.current_tool_name,
@@ -119,11 +148,17 @@ class AnthropicStreamStateManager:
         self.current_tool_inputs = None
 
     def flush_all(self) -> list[message.Part]:
-        """Flush all accumulated content in order and return parts."""
-        self.flush_thinking()
-        self.flush_content()
+        """Flush all pending content in order and return parts."""
+        self.flush_pending_signature()
         self.flush_tool_call()
-        return list(self.parts)
+        return list(self.assistant_parts)
+
+    def get_partial_parts(self) -> list[message.Part]:
+        """Get accumulated parts excluding tool calls, with thinking degraded.
+
+        Filters out ToolCallPart and applies degrade_thinking_to_text.
+        """
+        return build_partial_parts(self.assistant_parts)
 
     def get_partial_message(self) -> message.AssistantMessage | None:
         """Build a partial AssistantMessage from accumulated state.
@@ -131,16 +166,7 @@ class AnthropicStreamStateManager:
         Flushes all accumulated content and returns the message with
         stop_reason="aborted". Returns None if no content has been accumulated.
         """
-        self.flush_thinking()
-        self.flush_content()
-        parts = degrade_thinking_to_text(list(self.parts))
-        if not parts:
-            return None
-        return message.AssistantMessage(
-            parts=parts,
-            response_id=self.response_id,
-            stop_reason="aborted",
-        )
+        return build_partial_message(self.assistant_parts, response_id=self.response_id)
 
 
 def build_payload(
@@ -226,17 +252,18 @@ async def parse_anthropic_stream(
                     case BetaThinkingDelta() as delta:
                         if delta.thinking:
                             metadata_tracker.record_token()
-                            state.accumulated_thinking.append(delta.thinking)
+                            state.append_thinking_text(delta.thinking)
                             yield message.ThinkingTextDelta(
                                 content=delta.thinking,
                                 response_id=state.response_id,
                             )
                     case BetaSignatureDelta() as delta:
-                        state.pending_signature = delta.signature
+                        state.set_pending_signature(delta.signature)
                     case BetaTextDelta() as delta:
                         if delta.text:
                             metadata_tracker.record_token()
-                            state.accumulated_content.append(delta.text)
+                            state.flush_pending_signature()
+                            state.append_text(delta.text)
                             yield message.AssistantTextDelta(
                                 content=delta.text,
                                 response_id=state.response_id,
@@ -251,6 +278,7 @@ async def parse_anthropic_stream(
                 match event.content_block:
                     case BetaToolUseBlock() as block:
                         metadata_tracker.record_token()
+                        state.flush_pending_signature()
                         yield message.ToolCallStartDelta(
                             response_id=state.response_id,
                             call_id=block.id,
@@ -262,12 +290,7 @@ async def parse_anthropic_stream(
                     case _:
                         pass
             case BetaRawContentBlockStopEvent():
-                if state.accumulated_thinking:
-                    metadata_tracker.record_token()
-                    state.flush_thinking()
-                if state.accumulated_content:
-                    metadata_tracker.record_token()
-                    state.flush_content()
+                state.flush_pending_signature()
                 if state.current_tool_name and state.current_tool_call_id:
                     metadata_tracker.record_token()
                     state.flush_tool_call()
@@ -337,8 +360,10 @@ class AnthropicLLMStream(LLMStreamABC):
             self._metadata_tracker.set_model_name(str(self._param.model_id))
             self._metadata_tracker.set_response_id(self._state.response_id)
             metadata = self._metadata_tracker.finalize()
+            # Use accumulated parts for potential prefill on retry
+            self._state.flush_all()
             yield message.AssistantMessage(
-                parts=[],
+                parts=self._state.get_partial_parts(),
                 response_id=self._state.response_id,
                 usage=metadata,
                 stop_reason="error",