klaude-code 1.2.7__tar.gz → 1.2.8__tar.gz

{klaude_code-1.2.7 → klaude_code-1.2.8}/PKG-INFO

@@ -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 → klaude_code-1.2.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "1.2.7"
+version = "1.2.8"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.13"

{klaude_code-1.2.7 → klaude_code-1.2.8}/src/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-1.2.7 → klaude_code-1.2.8}/src/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-1.2.7 → klaude_code-1.2.8}/src/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-1.2.7 → klaude_code-1.2.8}/src/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-1.2.7 → klaude_code-1.2.8}/src/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-1.2.7 → klaude_code-1.2.8}/src/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-1.2.7 → klaude_code-1.2.8}/src/klaude_code/protocol/events.py

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

{klaude_code-1.2.7 → klaude_code-1.2.8}/src/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-1.2.7 → klaude_code-1.2.8}/src/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-1.2.7 → klaude_code-1.2.8}/src/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):