klaude-code 1.2.7__py3-none-any.whl → 1.2.8__py3-none-any.whl

klaude_code/core/task.py

@@ -79,10 +79,6 @@ class MetadataAccumulator:
             accumulated.model_name = turn_metadata.model_name
         if turn_metadata.response_id:
             accumulated.response_id = turn_metadata.response_id
-        if turn_metadata.status is not None:
-            accumulated.status = turn_metadata.status
-        if turn_metadata.error_reason is not None:
-            accumulated.error_reason = turn_metadata.error_reason
 
     def finalize(self, task_duration_s: float) -> model.ResponseMetadataItem:
         """Return the final accumulated metadata with computed throughput and duration."""

klaude_code/core/turn.py

@@ -38,6 +38,16 @@ class TurnExecutionContext:
     todo_context: TodoContext
 
 
+@dataclass
+class TurnResult:
+    """Aggregated state produced while executing a turn."""
+
+    reasoning_items: list[model.ReasoningTextItem | model.ReasoningEncryptedItem]
+    assistant_message: model.AssistantMessageItem | None
+    tool_calls: list[model.ToolCallItem]
+    stream_error: model.StreamErrorItem | None
+
+
 def build_events_from_tool_executor_event(session_id: str, event: ToolExecutorEvent) -> list[events.Event]:
     """Translate internal tool executor events into public protocol events."""
 
@@ -113,12 +123,34 @@ class TurnExecutor:
 
         yield events.TurnStartEvent(session_id=ctx.session_id)
 
-        turn_reasoning_items: list[model.ReasoningTextItem | model.ReasoningEncryptedItem] = []
-        turn_assistant_message: model.AssistantMessageItem | None = None
-        turn_tool_calls: list[model.ToolCallItem] = []
-        response_failed = False
-        error_message: str | None = None
+        turn_result = TurnResult(
+            reasoning_items=[],
+            assistant_message=None,
+            tool_calls=[],
+            stream_error=None,
+        )
+
+        async for event in self._consume_llm_stream(turn_result):
+            yield event
+
+        if turn_result.stream_error is not None:
+            ctx.append_history([turn_result.stream_error])
+            yield events.TurnEndEvent(session_id=ctx.session_id)
+            raise TurnError(turn_result.stream_error.error)
+
+        self._append_success_history(turn_result)
+        self._has_tool_call = bool(turn_result.tool_calls)
+
+        if turn_result.tool_calls:
+            async for ui_event in self._run_tool_executor(turn_result.tool_calls):
+                yield ui_event
+
+        yield events.TurnEndEvent(session_id=ctx.session_id)
 
+    async def _consume_llm_stream(self, turn_result: TurnResult) -> AsyncGenerator[events.Event, None]:
+        """Stream events from LLM and update turn_result in place."""
+
+        ctx = self._context
         async for response_item in ctx.llm_client.call(
             llm_param.LLMCallParameter(
                 input=ctx.get_conversation_history(),
@@ -136,16 +168,16 @@ class TurnExecutor:
             )
             match response_item:
                 case model.StartItem():
-                    pass
+                    continue
                 case model.ReasoningTextItem() as item:
-                    turn_reasoning_items.append(item)
+                    turn_result.reasoning_items.append(item)
                     yield events.ThinkingEvent(
                         content=item.content,
                         response_id=item.response_id,
                         session_id=ctx.session_id,
                     )
                 case model.ReasoningEncryptedItem() as item:
-                    turn_reasoning_items.append(item)
+                    turn_result.reasoning_items.append(item)
                 case model.AssistantMessageDelta() as item:
                     yield events.AssistantMessageDeltaEvent(
                         content=item.content,
@@ -153,7 +185,7 @@ class TurnExecutor:
                         session_id=ctx.session_id,
                     )
                 case model.AssistantMessageItem() as item:
-                    turn_assistant_message = item
+                    turn_result.assistant_message = item
                     yield events.AssistantMessageEvent(
                         content=item.content or "",
                         response_id=item.response_id,
@@ -164,13 +196,8 @@ class TurnExecutor:
                         session_id=ctx.session_id,
                         metadata=item,
                     )
-                    status = item.status
-                    if status is not None and status != "completed":
-                        response_failed = True
-                        error_message = f"Response status: {status}"
                 case model.StreamErrorItem() as item:
-                    response_failed = True
-                    error_message = item.error
+                    turn_result.stream_error = item
                     log_debug(
                         "[StreamError]",
                         item.error,
@@ -186,35 +213,33 @@ class TurnExecutor:
                         arguments="",
                     )
                 case model.ToolCallItem() as item:
-                    turn_tool_calls.append(item)
+                    turn_result.tool_calls.append(item)
                 case _:
-                    pass
+                    continue
 
-        if response_failed:
-            yield events.TurnEndEvent(session_id=ctx.session_id)
-            raise TurnError(error_message or "Turn failed")
-
-        # Append to history only on success
-        if turn_reasoning_items:
-            ctx.append_history(turn_reasoning_items)
-        if turn_assistant_message:
-            ctx.append_history([turn_assistant_message])
-        if turn_tool_calls:
-            ctx.append_history(turn_tool_calls)
-            self._has_tool_call = True
-
-        # Execute tools
-        if turn_tool_calls:
-            with tool_context(ctx.file_tracker, ctx.todo_context):
-                executor = ToolExecutor(
-                    registry=ctx.tool_registry,
-                    append_history=ctx.append_history,
-                )
-                self._tool_executor = executor
+    def _append_success_history(self, turn_result: TurnResult) -> None:
+        """Persist successful turn artifacts to conversation history."""
+        ctx = self._context
+        if turn_result.reasoning_items:
+            ctx.append_history(turn_result.reasoning_items)
+        if turn_result.assistant_message:
+            ctx.append_history([turn_result.assistant_message])
+        if turn_result.tool_calls:
+            ctx.append_history(turn_result.tool_calls)
 
-                async for exec_event in executor.run_tools(turn_tool_calls):
+    async def _run_tool_executor(self, tool_calls: list[model.ToolCallItem]) -> AsyncGenerator[events.Event, None]:
+        """Run tools for the turn and translate executor events to UI events."""
+
+        ctx = self._context
+        with tool_context(ctx.file_tracker, ctx.todo_context):
+            executor = ToolExecutor(
+                registry=ctx.tool_registry,
+                append_history=ctx.append_history,
+            )
+            self._tool_executor = executor
+            try:
+                async for exec_event in executor.run_tools(tool_calls):
                     for ui_event in build_events_from_tool_executor_event(ctx.session_id, exec_event):
                         yield ui_event
+            finally:
                 self._tool_executor = None
-
-        yield events.TurnEndEvent(session_id=ctx.session_id)

klaude_code/llm/anthropic/client.py

@@ -5,7 +5,7 @@ from typing import override
 
 import anthropic
 import httpx
-from anthropic import RateLimitError
+from anthropic import APIError
 from anthropic.types.beta.beta_input_json_delta import BetaInputJSONDelta
 from anthropic.types.beta.beta_raw_content_block_delta_event import BetaRawContentBlockDeltaEvent
 from anthropic.types.beta.beta_raw_content_block_start_event import BetaRawContentBlockStartEvent
@@ -217,5 +217,5 @@ class AnthropicClient(LLMClientABC):
                         )
                     case _:
                         pass
-        except RateLimitError as e:
+        except (APIError, httpx.HTTPError) as e:
             yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")

klaude_code/llm/codex/client.py

@@ -5,6 +5,7 @@ from collections.abc import AsyncGenerator
 from typing import override
 
 import httpx
+import openai
 from openai import AsyncOpenAI
 
 from klaude_code.auth.codex.exceptions import CodexNotLoggedInError
@@ -20,9 +21,9 @@ from klaude_code.protocol import llm_param, model
 # Codex API configuration
 CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex"
 CODEX_HEADERS = {
-    "OpenAI-Beta": "responses=experimental",
     "originator": "codex_cli_rs",
-    "User-Agent": "GitHubCopilotChat/0.32.4",
+    # Mocked Codex-style user agent string
+    "User-Agent": "codex_cli_rs/0.0.0-klaude",
 }
 
 
@@ -87,30 +88,42 @@ class CodexClient(LLMClientABC):
         inputs = convert_history_to_input(param.input, param.model)
         tools = convert_tool_schema(param.tools)
 
-        stream = await call_with_logged_payload(
-            self.client.responses.create,
-            model=str(param.model),
-            tool_choice="auto",
-            parallel_tool_calls=True,
-            include=[
-                "reasoning.encrypted_content",
-            ],
-            store=False,  # Always False for Codex
-            stream=True,
-            input=inputs,
-            instructions=param.system,
-            tools=tools,
-            text={
-                "verbosity": param.verbosity,
-            },
-            prompt_cache_key=param.session_id or "",
-            reasoning={
-                "effort": param.thinking.reasoning_effort,
-                "summary": param.thinking.reasoning_summary,
-            }
-            if param.thinking and param.thinking.reasoning_effort
-            else None,
-        )
+        session_id = param.session_id or ""
+        # Must send conversation_id/session_id headers to improve ChatGPT backend prompt cache hit rate.
+        extra_headers: dict[str, str] = {}
+        if session_id:
+            extra_headers["conversation_id"] = session_id
+            extra_headers["session_id"] = session_id
+
+        try:
+            stream = await call_with_logged_payload(
+                self.client.responses.create,
+                model=str(param.model),
+                tool_choice="auto",
+                parallel_tool_calls=True,
+                include=[
+                    "reasoning.encrypted_content",
+                ],
+                store=False,  # Always False for Codex
+                stream=True,
+                input=inputs,
+                instructions=param.system,
+                tools=tools,
+                text={
+                    "verbosity": param.verbosity,
+                },
+                prompt_cache_key=session_id,
+                reasoning={
+                    "effort": param.thinking.reasoning_effort,
+                    "summary": param.thinking.reasoning_summary,
+                }
+                if param.thinking and param.thinking.reasoning_effort
+                else None,
+                extra_headers=extra_headers,
+            )
+        except (openai.OpenAIError, httpx.HTTPError) as e:
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
+            return
 
         async for item in parse_responses_stream(stream, param, self._config.cost, request_start_time):
             yield item

klaude_code/llm/openai_compatible/client.py

@@ -4,7 +4,7 @@ from typing import Literal, override
 
 import httpx
 import openai
-from openai import APIError, RateLimitError
+
 
 from klaude_code.llm.client import LLMClientABC, call_with_logged_payload
 from klaude_code.llm.input_common import apply_config_defaults
@@ -193,7 +193,7 @@ class OpenAICompatibleClient(LLMClientABC):
                                 name=tc.function.name,
                             )
                     accumulated_tool_calls.add(delta.tool_calls)
-        except (RateLimitError, APIError) as e:
+        except (openai.OpenAIError, httpx.HTTPError) as e:
             yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
 
         # Finalize

klaude_code/llm/responses/client.py

@@ -4,7 +4,8 @@ from collections.abc import AsyncGenerator
 from typing import TYPE_CHECKING, override
 
 import httpx
-from openai import AsyncAzureOpenAI, AsyncOpenAI, RateLimitError
+import openai
+from openai import AsyncAzureOpenAI, AsyncOpenAI
 from openai.types import responses
 
 from klaude_code.llm.client import LLMClientABC, call_with_logged_payload
@@ -138,8 +139,6 @@ async def parse_responses_stream(
                         usage=usage,
                         response_id=response_id,
                         model_name=str(param.model),
-                        status=event.response.status,
-                        error_reason=error_reason,
                     )
                     if event.response.status != "completed":
                         error_message = f"LLM response finished with status '{event.response.status}'"
@@ -159,7 +158,7 @@ async def parse_responses_stream(
                         style="red",
                         debug_type=DebugType.LLM_STREAM,
                     )
-    except RateLimitError as e:
+    except (openai.OpenAIError, httpx.HTTPError) as e:
         yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
 
 
@@ -198,34 +197,38 @@ class ResponsesClient(LLMClientABC):
         inputs = convert_history_to_input(param.input, param.model)
         tools = convert_tool_schema(param.tools)
 
-        stream = await call_with_logged_payload(
-            self.client.responses.create,
-            model=str(param.model),
-            tool_choice="auto",
-            parallel_tool_calls=True,
-            include=[
-                "reasoning.encrypted_content",
-            ],
-            store=param.store,
-            previous_response_id=param.previous_response_id,
-            stream=True,
-            temperature=param.temperature,
-            max_output_tokens=param.max_tokens,
-            input=inputs,
-            instructions=param.system,
-            tools=tools,
-            text={
-                "verbosity": param.verbosity,
-            },
-            prompt_cache_key=param.session_id or "",
-            reasoning={
-                "effort": param.thinking.reasoning_effort,
-                "summary": param.thinking.reasoning_summary,
-            }
-            if param.thinking and param.thinking.reasoning_effort
-            else None,
-            extra_headers={"extra": json.dumps({"session_id": param.session_id})},
-        )
+        try:
+            stream = await call_with_logged_payload(
+                self.client.responses.create,
+                model=str(param.model),
+                tool_choice="auto",
+                parallel_tool_calls=True,
+                include=[
+                    "reasoning.encrypted_content",
+                ],
+                store=param.store,
+                previous_response_id=param.previous_response_id,
+                stream=True,
+                temperature=param.temperature,
+                max_output_tokens=param.max_tokens,
+                input=inputs,
+                instructions=param.system,
+                tools=tools,
+                text={
+                    "verbosity": param.verbosity,
+                },
+                prompt_cache_key=param.session_id or "",
+                reasoning={
+                    "effort": param.thinking.reasoning_effort,
+                    "summary": param.thinking.reasoning_summary,
+                }
+                if param.thinking and param.thinking.reasoning_effort
+                else None,
+                extra_headers={"extra": json.dumps({"session_id": param.session_id})},
+            )
+        except (openai.OpenAIError, httpx.HTTPError) as e:
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
+            return
 
         async for item in parse_responses_stream(stream, param, self._config.cost, request_start_time):
             yield item

klaude_code/protocol/events.py

@@ -130,6 +130,7 @@ HistoryItemEvent = (
     | ResponseMetadataEvent
     | InterruptEvent
     | DeveloperMessageEvent
+    | ErrorEvent
 )
 
 

klaude_code/protocol/model.py

@@ -260,8 +260,6 @@ class ResponseMetadataItem(BaseModel):
     model_name: str = ""
     provider: str | None = None  # OpenRouter's provider name
     task_duration_s: float | None = None
-    status: str | None = None
-    error_reason: str | None = None
     created_at: datetime = Field(default_factory=datetime.now)
 
 

klaude_code/session/session.py

@@ -309,6 +309,11 @@ class Session(BaseModel):
                         session_id=self.id,
                         item=dm,
                     )
+                case model.StreamErrorItem() as se:
+                    yield events.ErrorEvent(
+                        error_message=se.error,
+                        can_retry=False,
+                    )
                 case _:
                     continue
             prev_item = it

klaude_code/ui/modes/repl/renderer.py

@@ -190,6 +190,8 @@ class REPLRenderer:
                 case events.InterruptEvent():
                     self.print()
                     self.print(r_user_input.render_interrupt())
+                case events.ErrorEvent() as e:
+                    self.display_error(e)
 
     def display_developer_message(self, e: events.DeveloperMessageEvent) -> None:
         if not r_developer.need_render_developer_message(e):

{klaude_code-1.2.7.dist-info → klaude_code-1.2.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.2.7
+Version: 1.2.8
 Summary: Add your description here
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: openai>=1.102.0

{klaude_code-1.2.7.dist-info → klaude_code-1.2.8.dist-info}/RECORD

@@ -47,7 +47,7 @@ klaude_code/core/prompts/prompt-subagent-oracle.md,sha256=hGtyDm_6UhJZUJwfXt5A-1
 klaude_code/core/prompts/prompt-subagent-webfetch.md,sha256=kHtJINbCRiRDrip_q6idHHU3CwbDfrVlpgtSZvugOWI,2304
 klaude_code/core/prompts/prompt-subagent.md,sha256=dmmdsOenbAOfqG6FmdR88spOLZkXmntDBs-cmZ9DN_g,897
 klaude_code/core/reminders.py,sha256=CTVIAqwU8bVB02eq9vI4Iha-xO4_MxaCr71maRpfwmE,18221
-klaude_code/core/task.py,sha256=h3UyU9yRY01Mhsshp5PZBpD3-B5z-s4Kb76gTS0ASO8,10102
+klaude_code/core/task.py,sha256=wh8fyfWd0JZj3BQtr1uiWoWf-O2N79Fyl2QufanQsOA,9886
 klaude_code/core/tool/__init__.py,sha256=GQjs6IXqtiKn8RI3OmM0wki8p16SBnvuHVBez4Z5xqo,2120
 klaude_code/core/tool/file/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 klaude_code/core/tool/file/apply_patch.py,sha256=gUukVxt0qEP2NLHiPsmFWOi0sOuW0FaUnN0BfZ6FcII,17257
@@ -87,17 +87,17 @@ klaude_code/core/tool/web/mermaid_tool.md,sha256=Ketpxpr7lz8238p5Q7ZzcyWchWd4dU6
 klaude_code/core/tool/web/mermaid_tool.py,sha256=GUwWcrakSZH_Jp61Q_i5TvwQj6sWMrIW0ZbNpJ0dVtE,2750
 klaude_code/core/tool/web/web_fetch_tool.md,sha256=_5U-LSoI86rD26nPb0D5BQCr6hj8eyF0UELSiyLznCA,347
 klaude_code/core/tool/web/web_fetch_tool.py,sha256=iu6kM_-90K8mqHbK9Loui96vICV7d8rmtss68rcFqw0,4958
-klaude_code/core/turn.py,sha256=_Jx0huYlUXXTvgEIo_LFisJnFYssdyZePELSw7d_vHg,8391
+klaude_code/core/turn.py,sha256=ylcsVa3WsyOAvzR7McZ3a0sF4avbsRwDpoevujJruo8,9303
 klaude_code/llm/__init__.py,sha256=hjegW9bOyTZ6tN6TxQaMWKkEOuapgK2LJ0vWs9FLj_c,594
 klaude_code/llm/anthropic/__init__.py,sha256=PWETvaeNAAX3ue0ww1uRUIxTJG0RpWiutkn7MlwKxBs,67
-klaude_code/llm/anthropic/client.py,sha256=yEsp3JSVj-18y-UiYT6zQUMRg8PYJ-Ao3bSPSBiJSJM,11166
+klaude_code/llm/anthropic/client.py,sha256=0PyIjCTgxJWk8kS6MpEegxykvlsRRTnhvrThBjMlIdU,11173
 klaude_code/llm/anthropic/input.py,sha256=qPo4nmhnhSfLqef4UUVoIz8EjoXTxvlsrfsc_6qqM_s,8039
 klaude_code/llm/client.py,sha256=Un5LA5Z622JQ1MYEfJi7gXj3ycX3ce0WvYPcOogM32Y,1527
 klaude_code/llm/codex/__init__.py,sha256=8vN2j2ezWB_UVpfqQ8ooStsBeLL5SY4SUMXOXdWiMaI,132
-klaude_code/llm/codex/client.py,sha256=CKBIC9G9uvTxzNDE8sadSotQ8hVXpMWydb7aC-fVv_s,4182
+klaude_code/llm/codex/client.py,sha256=i7l4fQCgyUBn8MndSnsrjXRWA4yWZpN-UJnrUr5kN54,4824
 klaude_code/llm/input_common.py,sha256=yLn-g9T_lC3AnPPilFwlKEA2-vnIgyOKlHFBYB00jm8,8972
 klaude_code/llm/openai_compatible/__init__.py,sha256=ACGpnki7k53mMcCl591aw99pm9jZOZk0ghr7atOfNps,81
-klaude_code/llm/openai_compatible/client.py,sha256=LqwkmKZdgDJq8_zlwsb35-QRhunP-ec0VFKMr-SM_uk,9215
+klaude_code/llm/openai_compatible/client.py,sha256=hidXCXqsVdDbN_R-J5gjCTs1IXrLW_HRebqdu1PTGnM,9183
 klaude_code/llm/openai_compatible/input.py,sha256=AispOfSlQPmFWPgDYs2j3Q_2zwpYyZDf6oQNG8Z5q1M,3590
 klaude_code/llm/openai_compatible/tool_call_accumulator.py,sha256=kuw3ceDgenQz2Ccc9KYqBkDo6F1sDb5Aga6m41AIECA,4071
 klaude_code/llm/openrouter/__init__.py,sha256=_As8lHjwj6vapQhLorZttTpukk5ZiCdhFdGT38_ASPo,69
@@ -106,14 +106,14 @@ klaude_code/llm/openrouter/input.py,sha256=JrO3T8XMRumjwDoP4sc1UKTU9K_BFot63pi83
 klaude_code/llm/openrouter/reasoning_handler.py,sha256=TYIHdwMopi8DVqOpeN3vpyp-GcWOZgTeRnT5QvlK70U,8100
 klaude_code/llm/registry.py,sha256=KBKSelBLlGooInpzfVztN6OZqqfc0WzmB-cT8lE5fw8,686
 klaude_code/llm/responses/__init__.py,sha256=WsiyvnNiIytaYcaAqNiB8GI-5zcpjjeODPbMlteeFjA,67
-klaude_code/llm/responses/client.py,sha256=f1CoXjst1orWQ7eZujpOCBTrUfX0DLU5YTezEna68Lw,10594
+klaude_code/llm/responses/client.py,sha256=5-c0DH-9chtkGCoBe4tgYXatwj2XmlF83TRfE0Zsn9w,10795
 klaude_code/llm/responses/input.py,sha256=hnTnOGpo1-N_vsi7C3O_PJoj-Gf1cBdt9Q1sal3vhYM,6079
 klaude_code/llm/usage.py,sha256=CsZ3eAkt8lwJ47r0UV1fThu32tBBPAr-Zjc_-xq63rY,4302
 klaude_code/protocol/__init__.py,sha256=aGUgzhYqvhuT3Mk2vj7lrHGriH4h9TSbqV1RsRFAZjQ,194
 klaude_code/protocol/commands.py,sha256=zoqyBSpFZI8q8LP3rlr1mR-ekCufx-DfPGbzqsgx7X8,544
-klaude_code/protocol/events.py,sha256=Pw8lY7rJLwk-FjKWtX8C_-Op7p0KWLaI-PH1_U7Uoyg,3290
+klaude_code/protocol/events.py,sha256=DYICx6ALXVvVDENNIVQWlewm1pmSAxMjsrApeLahnck,3307
 klaude_code/protocol/llm_param.py,sha256=Hjq8Z-3nGhAJovf-lcsNc0kBVGRDWKe910J5lZwQfq4,4424
-klaude_code/protocol/model.py,sha256=7pSKURu6FLetkD6MlnpGZqTXclJSv6Uxj1GgreVs0XM,7816
+klaude_code/protocol/model.py,sha256=VT2ESJFKyTCy05T1yY0_QVL381qKbkQM3Sx66kon5TU,7750
 klaude_code/protocol/op.py,sha256=rkPvDRsOgPyibMI1n0pDO7ghFWJBfDGas9BnACtmfO4,2654
 klaude_code/protocol/op_handler.py,sha256=_lnv3-RxKkrTfGTNBlQ23gbHJBEtMLC8O48SYWDtPjE,843
 klaude_code/protocol/sub_agent.py,sha256=M17Cu58xC40j2pQF0cjeFaGtfLOMjiNIHNzE7Ej50LQ,13419
@@ -121,7 +121,7 @@ klaude_code/protocol/tools.py,sha256=hkjVirnQqGTJS46IWvVKXWR4usPPUgDZDnm34LzAVSc
 klaude_code/session/__init__.py,sha256=oXcDA5w-gJCbzmlF8yuWy3ezIW9DgFBNUs-gJHUJ-Rc,121
 klaude_code/session/export.py,sha256=lmU_X_NjNP3G8SNF2dxZk2wp4Q4S0KM4UYU200fZE5s,23573
 klaude_code/session/selector.py,sha256=HTboyzih7V8zbZoSsArJ-GVC1EnXTGocHJwFmZfbeSg,2567
-klaude_code/session/session.py,sha256=KLE3QUNvt8d7Zu_Mj2x6rdHygzsUtLsvMzQbsiIOrKg,19195
+klaude_code/session/session.py,sha256=1s9KmpgqBXBDyPH04udYMAE3FynGyrpXY7oQIoxXVTI,19403
 klaude_code/session/templates/export_session.html,sha256=q8CradCANsE2uj00qnH6v1KV5QZQPHSWzxXcVCVT0qk,41406
 klaude_code/trace/__init__.py,sha256=B-S4qdCj8W88AaC_gVmhTaejH6eLYClBVh2Q6aGAVBk,184
 klaude_code/trace/log.py,sha256=0K0uek2KWq0zkUZijcO-TBM6STLe-h_8IIW0lx7V7ZA,4865
@@ -142,7 +142,7 @@ klaude_code/ui/modes/repl/display.py,sha256=v-Jxe7MWpOCEsx9FFEzqKaIg0jLS7ZU9bevo
 klaude_code/ui/modes/repl/event_handler.py,sha256=5I8Ds1AfUF9eZtKiq99p_Vh3GMB-VV8YjWvwDuUv96c,15812
 klaude_code/ui/modes/repl/input_prompt_toolkit.py,sha256=wwXTQ_ZP70y_SgIQenttY82aBZDsRYhxerEqm46gpOM,7592
 klaude_code/ui/modes/repl/key_bindings.py,sha256=Px-QdRHkzvb2fDGg5d3JHic5ieiGiPcXorPJ5bAM8dI,7801
-klaude_code/ui/modes/repl/renderer.py,sha256=o1QubSm9lej-bVZ1G3ie-5qRxgPMDUo42kC9dTZRkvU,11893
+klaude_code/ui/modes/repl/renderer.py,sha256=0BQZxHG1zMqMt6I31zNkN7Nl2hQxVoryClXXZIjOLys,11982
 klaude_code/ui/renderers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 klaude_code/ui/renderers/assistant.py,sha256=Dxy6v4pX28RyWhnrjBteY8_NvDIi_jQa-j0mWt-eqWY,569
 klaude_code/ui/renderers/common.py,sha256=TPH7LCbeJGqB8ArTsVitqJHEyOxHU6nwnRtvF04nLJ4,184
@@ -170,7 +170,7 @@ klaude_code/ui/utils/__init__.py,sha256=YEsCLjbCPaPza-UXTPUMTJTrc9BmNBUP5CbFWlsh
 klaude_code/ui/utils/common.py,sha256=xzw-Mgj0agxrf22QxpH7YzVIpkMXIRY6SgXWtLYF0yU,2881
 klaude_code/ui/utils/debouncer.py,sha256=TFF1z7B7-FxONEigkYohhShDlqo4cOcqydE9zz7JBHc,1270
 klaude_code/version.py,sha256=QDgEqSFhyTSiABQFQc9VfujMPQcdjgoCaYTQsr94x0Q,4752
-klaude_code-1.2.7.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-klaude_code-1.2.7.dist-info/entry_points.txt,sha256=7CWKjolvs6dZiYHpelhA_FRJ-sVDh43eu3iWuOhKc_w,53
-klaude_code-1.2.7.dist-info/METADATA,sha256=B8198x-bOx9HK5McY8m6q4WtnFLQ3evMLkYDhorFLtM,5140
-klaude_code-1.2.7.dist-info/RECORD,,
+klaude_code-1.2.8.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+klaude_code-1.2.8.dist-info/entry_points.txt,sha256=7CWKjolvs6dZiYHpelhA_FRJ-sVDh43eu3iWuOhKc_w,53
+klaude_code-1.2.8.dist-info/METADATA,sha256=yaLap7nVbPl0CLFhi9dpa8e_kSZrleziUA76nOy6a20,5140
+klaude_code-1.2.8.dist-info/RECORD,,