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

klaude_code/core/tool/file/write_tool.py

@@ -7,38 +7,13 @@ from pathlib import Path
 
 from pydantic import BaseModel
 
+from klaude_code.core.tool.file._utils import file_exists, is_directory, read_text, write_text
 from klaude_code.core.tool.tool_abc import ToolABC, load_desc
 from klaude_code.core.tool.tool_context import get_current_file_tracker
 from klaude_code.core.tool.tool_registry import register
 from klaude_code.protocol import llm_param, model, tools
 
 
-def _is_directory(path: str) -> bool:
-    try:
-        return Path(path).is_dir()
-    except Exception:
-        return False
-
-
-def _file_exists(path: str) -> bool:
-    try:
-        return Path(path).exists()
-    except Exception:
-        return False
-
-
-def _write_text(path: str, content: str) -> None:
-    parent = Path(path).parent
-    parent.mkdir(parents=True, exist_ok=True)
-    with open(path, "w", encoding="utf-8") as f:
-        f.write(content)
-
-
-def _read_text(path: str) -> str:
-    with open(path, "r", encoding="utf-8", errors="replace") as f:
-        return f.read()
-
-
 class WriteArguments(BaseModel):
     file_path: str
     content: str
@@ -78,14 +53,14 @@ class WriteTool(ToolABC):
 
         file_path = os.path.abspath(args.file_path)
 
-        if _is_directory(file_path):
+        if is_directory(file_path):
             return model.ToolResultItem(
                 status="error",
                 output="<tool_use_error>Illegal operation on a directory. write</tool_use_error>",
             )
 
         file_tracker = get_current_file_tracker()
-        exists = _file_exists(file_path)
+        exists = file_exists(file_path)
 
         if exists:
             tracked_mtime: float | None = None
@@ -113,12 +88,12 @@ class WriteTool(ToolABC):
         before = ""
         if exists:
             try:
-                before = await asyncio.to_thread(_read_text, file_path)
+                before = await asyncio.to_thread(read_text, file_path)
             except Exception:
                 before = ""
 
         try:
-            await asyncio.to_thread(_write_text, file_path, args.content)
+            await asyncio.to_thread(write_text, file_path, args.content)
         except Exception as e:  # pragma: no cover
             return model.ToolResultItem(status="error", output=f"<tool_use_error>{e}</tool_use_error>")
 
@@ -140,7 +115,7 @@ class WriteTool(ToolABC):
             )
         )
         diff_text = "\n".join(diff_lines)
-        ui_extra = model.ToolResultUIExtra(type=model.ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text)
+        ui_extra = model.DiffTextUIExtra(diff_text=diff_text)
 
         message = f"File {'overwritten' if exists else 'created'} successfully at: {file_path}"
         return model.ToolResultItem(status="success", output=message, ui_extra=ui_extra)

klaude_code/core/tool/memory/__init__.py

@@ -0,0 +1,5 @@
+from .skill_loader import SkillLoader
+from .skill_tool import SkillTool
+
+skill_loader = SkillLoader()
+SkillTool.set_skill_loader(skill_loader)

klaude_code/core/tool/memory/memory_tool.py

@@ -100,7 +100,7 @@ def _format_numbered_line(line_no: int, content: str) -> str:
     return f"{line_no:>6}|{content}"
 
 
-def _make_diff_ui_extra(before: str, after: str, path: str) -> model.ToolResultUIExtra:
+def _make_diff_ui_extra(before: str, after: str, path: str) -> model.DiffTextUIExtra:
     diff_lines = list(
         difflib.unified_diff(
             before.splitlines(),
@@ -111,7 +111,7 @@ def _make_diff_ui_extra(before: str, after: str, path: str) -> model.ToolResultU
         )
     )
     diff_text = "\n".join(diff_lines)
-    return model.ToolResultUIExtra(type=model.ToolResultUIExtraType.DIFF_TEXT, diff_text=diff_text)
+    return model.DiffTextUIExtra(diff_text=diff_text)
 
 
 @register(tools.MEMORY)

klaude_code/core/tool/memory/skill_loader.py

@@ -115,7 +115,8 @@ class SkillLoader:
 
             return skill
 
-        except Exception:
+        except (OSError, yaml.YAMLError) as e:
+            log_debug(f"Failed to load skill from {skill_path}: {e}")
             return None
 
     def discover_skills(self) -> list[Skill]:

klaude_code/core/tool/memory/skill_tool.py

@@ -13,15 +13,26 @@ class SkillTool(ToolABC):
     """Tool to execute/load a skill within the main conversation"""
 
     _skill_loader: SkillLoader | None = None
+    _discovery_done: bool = False
 
     @classmethod
     def set_skill_loader(cls, loader: SkillLoader) -> None:
         """Set the skill loader instance"""
         cls._skill_loader = loader
+        cls._discovery_done = False
+
+    @classmethod
+    def _ensure_skills_discovered(cls) -> None:
+        if cls._discovery_done:
+            return
+        if cls._skill_loader is not None:
+            cls._skill_loader.discover_skills()
+        cls._discovery_done = True
 
     @classmethod
     def schema(cls) -> llm_param.ToolSchema:
         """Generate schema with embedded available skills metadata"""
+        cls._ensure_skills_discovered()
         skills_xml = cls._generate_skills_xml()
 
         return llm_param.ToolSchema(
@@ -69,6 +80,8 @@ class SkillTool(ToolABC):
                 output=f"Invalid arguments: {e}",
             )
 
+        cls._ensure_skills_discovered()
+
         if not cls._skill_loader:
             return model.ToolResultItem(
                 status="error",

klaude_code/core/tool/sub_agent_tool.py

@@ -79,5 +79,6 @@ class SubAgentTool(ToolABC):
         return model.ToolResultItem(
             status="success" if not result.error else "error",
             output=result.task_result or "",
-            ui_extra=model.ToolResultUIExtra(type=model.ToolResultUIExtraType.SESSION_ID, session_id=result.session_id),
+            ui_extra=model.SessionIdUIExtra(session_id=result.session_id),
+            task_metadata=result.task_metadata,
         )

klaude_code/core/tool/todo/todo_write_tool.py

@@ -116,6 +116,6 @@ Your todo list has changed. DO NOT mention this explicitly to the user. Here are
         return model.ToolResultItem(
             status="success",
             output=response,
-            ui_extra=model.ToolResultUIExtra(type=model.ToolResultUIExtraType.TODO_LIST, todo_list=ui_extra),
+            ui_extra=model.TodoListUIExtra(todo_list=ui_extra),
             side_effects=[model.ToolSideEffect.TODO_CHANGE],
         )

klaude_code/core/tool/todo/update_plan_tool.py

@@ -99,6 +99,6 @@ class UpdatePlanTool(ToolABC):
         return model.ToolResultItem(
             status="success",
             output="Plan updated",
-            ui_extra=model.ToolResultUIExtra(type=model.ToolResultUIExtraType.TODO_LIST, todo_list=ui_extra),
+            ui_extra=model.TodoListUIExtra(todo_list=ui_extra),
             side_effects=[model.ToolSideEffect.TODO_CHANGE],
         )

klaude_code/core/tool/tool_context.py

@@ -22,6 +22,19 @@ class TodoContext:
     set_todos: Callable[[list[model.TodoItem]], None]
 
 
+@dataclass
+class SessionTodoStore:
+    """Adapter exposing session todos through an explicit interface."""
+
+    session: Session
+
+    def get(self) -> list[model.TodoItem]:
+        return self.session.todos
+
+    def set(self, todos: list[model.TodoItem]) -> None:
+        self.session.todos = todos
+
+
 @dataclass
 class ToolContextToken:
     """Tokens used to restore tool execution context.
@@ -55,10 +68,7 @@ def set_tool_context_from_session(session: Session) -> ToolContextToken:
     """
 
     file_tracker_token = current_file_tracker_var.set(session.file_tracker)
-    todo_ctx = TodoContext(
-        get_todos=lambda: session.todos,
-        set_todos=lambda todos: setattr(session, "todos", todos),
-    )
+    todo_ctx = build_todo_context(session)
     todo_token = current_todo_context_var.set(todo_ctx)
     return ToolContextToken(file_tracker_token=file_tracker_token, todo_token=todo_token)
 
@@ -87,6 +97,13 @@ def tool_context(
         reset_tool_context(token)
 
 
+def build_todo_context(session: Session) -> TodoContext:
+    """Create a TodoContext backed by the given session."""
+
+    store = SessionTodoStore(session)
+    return TodoContext(get_todos=store.get, set_todos=store.set)
+
+
 def get_current_file_tracker() -> MutableMapping[str, float] | None:
     """Return the current file tracker mapping for this tool context."""
 

klaude_code/core/tool/tool_runner.py

@@ -34,13 +34,10 @@ async def run_tool(tool_call: model.ToolCallItem, registry: dict[str, type[ToolA
             truncation_result = truncate_tool_output(tool_result.output, tool_call)
             tool_result.output = truncation_result.output
             if truncation_result.was_truncated and truncation_result.saved_file_path:
-                tool_result.ui_extra = model.ToolResultUIExtra(
-                    type=model.ToolResultUIExtraType.TRUNCATION,
-                    truncation=model.TruncationUIExtra(
-                        saved_file_path=truncation_result.saved_file_path,
-                        original_length=truncation_result.original_length,
-                        truncated_length=truncation_result.truncated_length,
-                    ),
+                tool_result.ui_extra = model.TruncationUIExtra(
+                    saved_file_path=truncation_result.saved_file_path,
+                    original_length=truncation_result.original_length,
+                    truncated_length=truncation_result.truncated_length,
                 )
         return tool_result
     except asyncio.CancelledError:
@@ -244,7 +241,7 @@ class ToolExecutor:
         for side_effect in side_effects:
             if side_effect == model.ToolSideEffect.TODO_CHANGE:
                 todos: list[model.TodoItem] | None = None
-                if tool_result.ui_extra is not None and tool_result.ui_extra.todo_list is not None:
+                if isinstance(tool_result.ui_extra, model.TodoListUIExtra):
                     todos = tool_result.ui_extra.todo_list.todos
                 if todos is not None:
                     side_effect_events.append(ToolExecutionTodoChange(todos=todos))

klaude_code/core/tool/web/mermaid_tool.py

@@ -49,10 +49,7 @@ class MermaidTool(ToolABC):
 
         link = cls._build_link(args.code)
         line_count = cls._count_lines(args.code)
-        ui_extra = model.ToolResultUIExtra(
-            type=model.ToolResultUIExtraType.MERMAID_LINK,
-            mermaid_link=model.MermaidLinkUIExtra(link=link, line_count=line_count),
-        )
+        ui_extra = model.MermaidLinkUIExtra(link=link, line_count=line_count)
         output = f"Mermaid diagram rendered successfully ({line_count} lines)."
         return model.ToolResultItem(status="success", output=output, ui_extra=ui_extra)
 

klaude_code/core/turn.py

@@ -1,9 +1,14 @@
 from __future__ import annotations
 
-from collections.abc import AsyncGenerator, Callable, MutableMapping, Sequence
+from collections.abc import AsyncGenerator
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from klaude_code.core.tool import ToolABC, tool_context
+
+if TYPE_CHECKING:
+    from klaude_code.core.task import SessionContext
 
-from klaude_code.core.tool import TodoContext, ToolABC, tool_context
 from klaude_code.core.tool.tool_runner import (
     ToolExecutionCallStarted,
     ToolExecutionResult,
@@ -26,16 +31,11 @@ class TurnError(Exception):
 class TurnExecutionContext:
     """Execution context required to run a single turn."""
 
-    session_id: str
-    get_conversation_history: Callable[[], list[model.ConversationItem]]
-    append_history: Callable[[Sequence[model.ConversationItem]], None]
+    session_ctx: SessionContext
     llm_client: LLMClientABC
     system_prompt: str | None
     tools: list[llm_param.ToolSchema]
     tool_registry: dict[str, type[ToolABC]]
-    # For tool context
-    file_tracker: MutableMapping[str, float]
-    todo_context: TodoContext
 
 
 @dataclass
@@ -74,6 +74,7 @@ def build_events_from_tool_executor_event(session_id: str, event: ToolExecutorEv
                     result=tool_result.output or "",
                     ui_extra=tool_result.ui_extra,
                     status=tool_result.status,
+                    task_metadata=tool_result.task_metadata,
                 )
             )
         case ToolExecutionTodoChange(todos=todos):
@@ -97,18 +98,18 @@ class TurnExecutor:
     def __init__(self, context: TurnExecutionContext) -> None:
         self._context = context
         self._tool_executor: ToolExecutor | None = None
-        self._has_tool_call: bool = False
+        self._turn_result: TurnResult | None = None
 
     @property
     def has_tool_call(self) -> bool:
-        return self._has_tool_call
+        return bool(self._turn_result and self._turn_result.tool_calls)
 
     def cancel(self) -> list[events.Event]:
         """Cancel running tools and return any resulting events."""
         ui_events: list[events.Event] = []
         if self._tool_executor is not None:
             for exec_event in self._tool_executor.cancel():
-                for ui_event in build_events_from_tool_executor_event(self._context.session_id, exec_event):
+                for ui_event in build_events_from_tool_executor_event(self._context.session_ctx.session_id, exec_event):
                     ui_events.append(ui_event)
             self._tool_executor = None
         return ui_events
@@ -120,44 +121,45 @@ class TurnExecutor:
             TurnError: If the turn fails (stream error or non-completed status).
         """
         ctx = self._context
+        session_ctx = ctx.session_ctx
 
-        yield events.TurnStartEvent(session_id=ctx.session_id)
+        yield events.TurnStartEvent(session_id=session_ctx.session_id)
 
-        turn_result = TurnResult(
+        self._turn_result = TurnResult(
             reasoning_items=[],
             assistant_message=None,
             tool_calls=[],
             stream_error=None,
         )
 
-        async for event in self._consume_llm_stream(turn_result):
+        async for event in self._consume_llm_stream(self._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)
+        if self._turn_result.stream_error is not None:
+            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)
 
-        self._append_success_history(turn_result)
-        self._has_tool_call = bool(turn_result.tool_calls)
+        self._append_success_history(self._turn_result)
 
-        if turn_result.tool_calls:
-            async for ui_event in self._run_tool_executor(turn_result.tool_calls):
+        if self._turn_result.tool_calls:
+            async for ui_event in self._run_tool_executor(self._turn_result.tool_calls):
                 yield ui_event
 
-        yield events.TurnEndEvent(session_id=ctx.session_id)
+        yield events.TurnEndEvent(session_id=session_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
+        session_ctx = ctx.session_ctx
         async for response_item in ctx.llm_client.call(
             llm_param.LLMCallParameter(
-                input=ctx.get_conversation_history(),
+                input=session_ctx.get_conversation_history(),
                 system=ctx.system_prompt,
                 tools=ctx.tools,
                 store=False,
-                session_id=ctx.session_id,
+                session_id=session_ctx.session_id,
             )
         ):
             log_debug(
@@ -174,7 +176,7 @@ class TurnExecutor:
                     yield events.ThinkingEvent(
                         content=item.content,
                         response_id=item.response_id,
-                        session_id=ctx.session_id,
+                        session_id=session_ctx.session_id,
                     )
                 case model.ReasoningEncryptedItem() as item:
                     turn_result.reasoning_items.append(item)
@@ -182,18 +184,18 @@ class TurnExecutor:
                     yield events.AssistantMessageDeltaEvent(
                         content=item.content,
                         response_id=item.response_id,
-                        session_id=ctx.session_id,
+                        session_id=session_ctx.session_id,
                     )
                 case model.AssistantMessageItem() as item:
                     turn_result.assistant_message = item
                     yield events.AssistantMessageEvent(
                         content=item.content or "",
                         response_id=item.response_id,
-                        session_id=ctx.session_id,
+                        session_id=session_ctx.session_id,
                     )
                 case model.ResponseMetadataItem() as item:
                     yield events.ResponseMetadataEvent(
-                        session_id=ctx.session_id,
+                        session_id=session_ctx.session_id,
                         metadata=item,
                     )
                 case model.StreamErrorItem() as item:
@@ -206,7 +208,7 @@ class TurnExecutor:
                     )
                 case model.ToolCallStartItem() as item:
                     yield events.TurnToolCallStartEvent(
-                        session_id=ctx.session_id,
+                        session_id=session_ctx.session_id,
                         response_id=item.response_id,
                         tool_call_id=item.call_id,
                         tool_name=item.name,
@@ -219,27 +221,28 @@ class TurnExecutor:
 
     def _append_success_history(self, turn_result: TurnResult) -> None:
         """Persist successful turn artifacts to conversation history."""
-        ctx = self._context
+        session_ctx = self._context.session_ctx
         if turn_result.reasoning_items:
-            ctx.append_history(turn_result.reasoning_items)
+            session_ctx.append_history(turn_result.reasoning_items)
         if turn_result.assistant_message:
-            ctx.append_history([turn_result.assistant_message])
+            session_ctx.append_history([turn_result.assistant_message])
         if turn_result.tool_calls:
-            ctx.append_history(turn_result.tool_calls)
+            session_ctx.append_history(turn_result.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):
+        session_ctx = ctx.session_ctx
+        with tool_context(session_ctx.file_tracker, session_ctx.todo_context):
             executor = ToolExecutor(
                 registry=ctx.tool_registry,
-                append_history=ctx.append_history,
+                append_history=session_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):
+                    for ui_event in build_events_from_tool_executor_event(session_ctx.session_id, exec_event):
                         yield ui_event
             finally:
                 self._tool_executor = None

klaude_code/llm/__init__.py

@@ -1,23 +1,13 @@
 """LLM package init.
 
-Imports built-in LLM clients so their ``@register`` decorators run and they
-become available via the registry.
+LLM clients are lazily loaded to avoid heavy imports at module load time.
+Only LLMClientABC and create_llm_client are exposed.
 """
 
-from .anthropic import AnthropicClient
 from .client import LLMClientABC
-from .codex import CodexClient
-from .openai_compatible import OpenAICompatibleClient
-from .openrouter import OpenRouterClient
 from .registry import create_llm_client
-from .responses import ResponsesClient
 
 __all__ = [
     "LLMClientABC",
-    "ResponsesClient",
-    "OpenAICompatibleClient",
-    "OpenRouterClient",
-    "AnthropicClient",
-    "CodexClient",
     "create_llm_client",
 ]

klaude_code/llm/anthropic/client.py

@@ -1,5 +1,4 @@
 import json
-import time
 from collections.abc import AsyncGenerator
 from typing import override
 
@@ -22,7 +21,7 @@ from klaude_code.llm.anthropic.input import convert_history_to_input, convert_sy
 from klaude_code.llm.client import LLMClientABC, call_with_logged_payload
 from klaude_code.llm.input_common import apply_config_defaults
 from klaude_code.llm.registry import register
-from klaude_code.llm.usage import calculate_cost
+from klaude_code.llm.usage import MetadataTracker, convert_anthropic_usage
 from klaude_code.protocol import llm_param, model
 from klaude_code.trace import DebugType, log_debug
 
@@ -47,9 +46,7 @@ class AnthropicClient(LLMClientABC):
     async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
         param = apply_config_defaults(param, self.get_llm_config())
 
-        request_start_time = time.time()
-        first_token_time: float | None = None
-        last_token_time: float | None = None
+        metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
 
         messages = convert_history_to_input(param.input, param.model)
         tools = convert_tool_schema(param.tools)
@@ -77,7 +74,7 @@ class AnthropicClient(LLMClientABC):
             else anthropic.types.ThinkingConfigDisabledParam(
                 type="disabled",
             ),
-            extra_headers={"extra": json.dumps({"session_id": param.session_id})},
+            extra_headers={"extra": json.dumps({"session_id": param.session_id}, sort_keys=True)},
         )
 
         accumulated_thinking: list[str] = []
@@ -112,32 +109,24 @@ class AnthropicClient(LLMClientABC):
                     case BetaRawContentBlockDeltaEvent() as event:
                         match event.delta:
                             case BetaThinkingDelta() as delta:
-                                if first_token_time is None:
-                                    first_token_time = time.time()
-                                last_token_time = time.time()
+                                metadata_tracker.record_token()
                                 accumulated_thinking.append(delta.thinking)
                             case BetaSignatureDelta() as delta:
-                                if first_token_time is None:
-                                    first_token_time = time.time()
-                                last_token_time = time.time()
+                                metadata_tracker.record_token()
                                 yield model.ReasoningEncryptedItem(
                                     encrypted_content=delta.signature,
                                     response_id=response_id,
                                     model=str(param.model),
                                 )
                             case BetaTextDelta() as delta:
-                                if first_token_time is None:
-                                    first_token_time = time.time()
-                                last_token_time = time.time()
+                                metadata_tracker.record_token()
                                 accumulated_content.append(delta.text)
                                 yield model.AssistantMessageDelta(
                                     content=delta.text,
                                     response_id=response_id,
                                 )
                             case BetaInputJSONDelta() as delta:
-                                if first_token_time is None:
-                                    first_token_time = time.time()
-                                last_token_time = time.time()
+                                metadata_tracker.record_token()
                                 if current_tool_inputs is not None:
                                     current_tool_inputs.append(delta.partial_json)
                             case _:
@@ -184,37 +173,18 @@ class AnthropicClient(LLMClientABC):
                         input_tokens += (event.usage.input_tokens or 0) + (event.usage.cache_creation_input_tokens or 0)
                         output_tokens += event.usage.output_tokens or 0
                         cached_tokens += event.usage.cache_read_input_tokens or 0
-                        total_tokens = input_tokens + cached_tokens + output_tokens
-                        context_usage_percent = (
-                            (total_tokens / param.context_limit) * 100 if param.context_limit else None
-                        )
-
-                        throughput_tps: float | None = None
-                        first_token_latency_ms: float | None = None
-
-                        if first_token_time is not None:
-                            first_token_latency_ms = (first_token_time - request_start_time) * 1000
 
-                        if first_token_time is not None and last_token_time is not None and output_tokens > 0:
-                            time_duration = last_token_time - first_token_time
-                            if time_duration >= 0.15:
-                                throughput_tps = output_tokens / time_duration
-
-                        usage = model.Usage(
+                        usage = convert_anthropic_usage(
                             input_tokens=input_tokens,
                             output_tokens=output_tokens,
                             cached_tokens=cached_tokens,
-                            total_tokens=total_tokens,
-                            context_usage_percent=context_usage_percent,
-                            throughput_tps=throughput_tps,
-                            first_token_latency_ms=first_token_latency_ms,
-                        )
-                        calculate_cost(usage, self._config.cost)
-                        yield model.ResponseMetadataItem(
-                            usage=usage,
-                            response_id=response_id,
-                            model_name=str(param.model),
+                            context_limit=param.context_limit,
+                            max_tokens=param.max_tokens,
                         )
+                        metadata_tracker.set_usage(usage)
+                        metadata_tracker.set_model_name(str(param.model))
+                        metadata_tracker.set_response_id(response_id)
+                        yield metadata_tracker.finalize()
                     case _:
                         pass
         except (APIError, httpx.HTTPError) as e:

klaude_code/llm/client.py

@@ -19,7 +19,7 @@ class LLMClientABC(ABC):
     @abstractmethod
     async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
         raise NotImplementedError
-        yield cast(model.ConversationItem, None)  # pyright: ignore[reportUnreachable]
+        yield cast(model.ConversationItem, None)
 
     def get_llm_config(self) -> llm_param.LLMConfigParameter:
         return self._config
@@ -42,7 +42,7 @@ def call_with_logged_payload(func: Callable[P, R], *args: P.args, **kwargs: P.kw
 
     payload = {k: v for k, v in kwargs.items() if v is not None}
     log_debug(
-        json.dumps(payload, ensure_ascii=False, default=str),
+        json.dumps(payload, ensure_ascii=False, default=str, sort_keys=True),
         style="yellow",
         debug_type=DebugType.LLM_PAYLOAD,
     )

klaude_code/llm/codex/client.py

@@ -1,6 +1,5 @@
 """Codex LLM client using ChatGPT subscription via OAuth."""
 
-import time
 from collections.abc import AsyncGenerator
 from typing import override
 
@@ -16,6 +15,7 @@ from klaude_code.llm.input_common import apply_config_defaults
 from klaude_code.llm.registry import register
 from klaude_code.llm.responses.client import parse_responses_stream
 from klaude_code.llm.responses.input import convert_history_to_input, convert_tool_schema
+from klaude_code.llm.usage import MetadataTracker
 from klaude_code.protocol import llm_param, model
 
 # Codex API configuration
@@ -24,6 +24,7 @@ CODEX_HEADERS = {
     "originator": "codex_cli_rs",
     # Mocked Codex-style user agent string
     "User-Agent": "codex_cli_rs/0.0.0-klaude",
+    "OpenAI-Beta": "responses=experimental",
 }
 
 
@@ -83,7 +84,7 @@ class CodexClient(LLMClientABC):
         # Codex API requires store=False
         param.store = False
 
-        request_start_time = time.time()
+        metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
 
         inputs = convert_history_to_input(param.input, param.model)
         tools = convert_tool_schema(param.tools)
@@ -125,5 +126,5 @@ class CodexClient(LLMClientABC):
             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):
+        async for item in parse_responses_stream(stream, param, metadata_tracker):
             yield item