klaude-code 2.8.1__py3-none-any.whl → 2.9.1__py3-none-any.whl

klaude_code/tui/machine.py

@@ -32,7 +32,6 @@ from klaude_code.tui.commands import (
     RenderTaskFinish,
     RenderTaskMetadata,
     RenderTaskStart,
-    RenderThinkingHeader,
     RenderToolCall,
     RenderToolResult,
     RenderTurnStart,
@@ -49,7 +48,7 @@ from klaude_code.tui.commands import (
 from klaude_code.tui.components.rich import status as r_status
 from klaude_code.tui.components.rich.theme import ThemeKey
 from klaude_code.tui.components.thinking import extract_last_bold_header, normalize_thinking_content
-from klaude_code.tui.components.tools import get_tool_active_form, is_sub_agent_tool
+from klaude_code.tui.components.tools import get_task_active_form, get_tool_active_form, is_sub_agent_tool
 
 # Tools that complete quickly and don't benefit from streaming activity display.
 # For models without fine-grained tool JSON streaming (e.g., Gemini), showing these
@@ -68,25 +67,6 @@ FAST_TOOLS: frozenset[str] = frozenset(
 )
 
 
-@dataclass
-class SubAgentThinkingHeaderState:
-    buffer: str = ""
-    last_header: str | None = None
-
-    def append_and_extract_new_header(self, content: str) -> str | None:
-        self.buffer += content
-
-        max_chars = 8192
-        if len(self.buffer) > max_chars:
-            self.buffer = self.buffer[-max_chars:]
-
-        header = extract_last_bold_header(normalize_thinking_content(self.buffer))
-        if header and header != self.last_header:
-            self.last_header = header
-            return header
-        return None
-
-
 class ActivityState:
     """Tracks composing/tool activity for spinner display."""
 
@@ -97,10 +77,6 @@ class ActivityState:
         self._sub_agent_tool_calls: dict[str, int] = {}
         self._sub_agent_tool_calls_by_id: dict[str, str] = {}
 
-    @property
-    def is_composing(self) -> bool:
-        return self._composing and not self._tool_calls and not self._sub_agent_tool_calls
-
     def set_composing(self, composing: bool) -> None:
         self._composing = composing
         if not composing:
@@ -114,7 +90,10 @@ class ActivityState:
 
     def add_sub_agent_tool_call(self, tool_call_id: str, tool_name: str) -> None:
         if tool_call_id in self._sub_agent_tool_calls_by_id:
-            return
+            old_tool_name = self._sub_agent_tool_calls_by_id[tool_call_id]
+            self._sub_agent_tool_calls[old_tool_name] = self._sub_agent_tool_calls.get(old_tool_name, 0) - 1
+            if self._sub_agent_tool_calls[old_tool_name] <= 0:
+                self._sub_agent_tool_calls.pop(old_tool_name, None)
         self._sub_agent_tool_calls_by_id[tool_call_id] = tool_name
         self._sub_agent_tool_calls[tool_name] = self._sub_agent_tool_calls.get(tool_name, 0) + 1
 
@@ -307,7 +286,6 @@ class SpinnerStatusState:
 class _SessionState:
     session_id: str
     sub_agent_state: model.SubAgentState | None = None
-    sub_agent_thinking_header: SubAgentThinkingHeaderState | None = None
     model_id: str | None = None
     assistant_stream_active: bool = False
     thinking_stream_active: bool = False
@@ -321,7 +299,7 @@ class _SessionState:
 
     @property
     def should_show_sub_agent_thinking_header(self) -> bool:
-        return bool(self.sub_agent_state and self.sub_agent_state.sub_agent_type == "ImageGen")
+        return bool(self.sub_agent_state and self.sub_agent_state.sub_agent_type == tools.IMAGE_GEN)
 
     @property
     def should_extract_reasoning_header(self) -> bool:
@@ -422,8 +400,6 @@ class DisplayStateMachine:
                     self._set_primary_if_needed(e.session_id)
                     if not is_replay:
                         cmds.append(TaskClockStart())
-                else:
-                    s.sub_agent_thinking_header = SubAgentThinkingHeaderState()
 
                 if not is_replay:
                     cmds.append(SpinnerStart())
@@ -469,7 +445,11 @@ class DisplayStateMachine:
 
             case events.ThinkingStartEvent() as e:
                 if s.is_sub_agent:
-                    return []
+                    if not s.should_show_sub_agent_thinking_header:
+                        return []
+                    s.thinking_stream_active = True
+                    cmds.append(StartThinkingStream(session_id=e.session_id))
+                    return cmds
                 if not self._is_primary(e.session_id):
                     return []
                 s.thinking_stream_active = True
@@ -487,11 +467,7 @@ class DisplayStateMachine:
                 if s.is_sub_agent:
                     if not s.should_show_sub_agent_thinking_header:
                         return []
-                    if s.sub_agent_thinking_header is None:
-                        s.sub_agent_thinking_header = SubAgentThinkingHeaderState()
-                    header = s.sub_agent_thinking_header.append_and_extract_new_header(e.content)
-                    if header:
-                        cmds.append(RenderThinkingHeader(session_id=e.session_id, header=header))
+                    cmds.append(AppendThinking(session_id=e.session_id, content=e.content))
                     return cmds
 
                 if not self._is_primary(e.session_id):
@@ -511,7 +487,11 @@ class DisplayStateMachine:
 
             case events.ThinkingEndEvent() as e:
                 if s.is_sub_agent:
-                    return []
+                    if not s.should_show_sub_agent_thinking_header:
+                        return []
+                    s.thinking_stream_active = False
+                    cmds.append(EndThinkingStream(session_id=e.session_id))
+                    return cmds
                 if not self._is_primary(e.session_id):
                     return []
                 s.thinking_stream_active = False
@@ -629,12 +609,17 @@ class DisplayStateMachine:
                         primary.thinking_stream_active = False
                         cmds.append(EndThinkingStream(session_id=primary.session_id))
 
+                if not is_replay and e.tool_name == tools.TASK and not s.should_skip_tool_activity(e.tool_name):
+                    tool_active_form = get_task_active_form(e.arguments)
+                    self._spinner.add_sub_agent_tool_call(e.tool_call_id, tool_active_form)
+                    cmds.extend(self._spinner_update_commands())
+
                 cmds.append(RenderToolCall(e))
                 return cmds
 
             case events.ToolResultEvent() as e:
                 if not is_replay and is_sub_agent_tool(e.tool_name):
-                    self._spinner.finish_sub_agent_tool_call(e.tool_call_id, get_tool_active_form(e.tool_name))
+                    self._spinner.finish_sub_agent_tool_call(e.tool_call_id)
                     cmds.extend(self._spinner_update_commands())
 
                 if s.is_sub_agent and not e.is_error:
@@ -675,15 +660,12 @@ class DisplayStateMachine:
             case events.TaskFinishEvent() as e:
                 s.task_active = False
                 cmds.append(RenderTaskFinish(e))
-                if not s.is_sub_agent:
-                    if not is_replay:
-                        cmds.append(TaskClockClear())
-                        self._spinner.reset()
-                        cmds.append(SpinnerStop())
-                        cmds.append(PrintRuleLine())
-                        cmds.append(EmitTmuxSignal())
-                else:
-                    s.sub_agent_thinking_header = None
+                if not s.is_sub_agent and not is_replay:
+                    cmds.append(TaskClockClear())
+                    self._spinner.reset()
+                    cmds.append(SpinnerStop())
+                    cmds.append(PrintRuleLine())
+                    cmds.append(EmitTmuxSignal())
                 return cmds
 
             case events.InterruptEvent() as e:

klaude_code/tui/renderer.py

@@ -67,7 +67,7 @@ from klaude_code.tui.components import thinking as c_thinking
 from klaude_code.tui.components import tools as c_tools
 from klaude_code.tui.components import user_input as c_user_input
 from klaude_code.tui.components import welcome as c_welcome
-from klaude_code.tui.components.common import truncate_head
+from klaude_code.tui.components.common import create_grid, truncate_head
 from klaude_code.tui.components.rich import status as r_status
 from klaude_code.tui.components.rich.live import CropAboveLive, SingleLine
 from klaude_code.tui.components.rich.markdown import MarkdownStream, NoInsetMarkdown, ThinkingMarkdown
@@ -168,6 +168,7 @@ class TUICommandRenderer:
         self._sessions: dict[str, _SessionStatus] = {}
         self._current_sub_agent_color: Style | None = None
         self._sub_agent_color_index = 0
+        self._sub_agent_thinking_buffers: dict[str, str] = {}
 
     # ---------------------------------------------------------------------
     # Session helpers
@@ -184,13 +185,6 @@ class TUICommandRenderer:
     def is_sub_agent_session(self, session_id: str) -> bool:
         return session_id in self._sessions and self._sessions[session_id].sub_agent_state is not None
 
-    def _should_display_sub_agent_thinking_header(self, session_id: str) -> bool:
-        # Hardcoded: only show sub-agent thinking headers for ImageGen.
-        st = self._sessions.get(session_id)
-        if st is None or st.sub_agent_state is None:
-            return False
-        return st.sub_agent_state.sub_agent_type == "ImageGen"
-
     def _advance_sub_agent_color_index(self) -> None:
         palette_size = len(self.themes.sub_agent_colors)
         if palette_size == 0:
@@ -332,8 +326,7 @@ class TUICommandRenderer:
                 if pad_lines:
                     stream = Padding(stream, (0, 0, pad_lines, 0))
                 stream_part = stream
-
-            gap_part = Text("") if self._spinner_visible else Group()
+                gap_part = Text("")
 
         status_part: RenderableType = SingleLine(self._status_spinner) if self._spinner_visible else Group()
         return Group(stream_part, gap_part, status_part)
@@ -388,6 +381,19 @@ class TUICommandRenderer:
     def _flush_assistant(self) -> None:
         self._assistant_stream.render()
 
+    def _render_sub_agent_thinking(self, content: str) -> None:
+        """Render sub-agent thinking content as a single block."""
+        normalized = c_thinking.normalize_thinking_content(content)
+        if not normalized.strip():
+            return
+        md = ThinkingMarkdown(normalized, code_theme=self.themes.code_theme, style=ThemeKey.THINKING)
+        self.console.push_theme(self.themes.thinking_markdown_theme)
+        grid = create_grid()
+        grid.add_row(Text(c_thinking.THINKING_MESSAGE_MARK, style=ThemeKey.THINKING), md)
+        self.print(grid)
+        self.console.pop_theme()
+        self.print()
+
     # ---------------------------------------------------------------------
     # Event-specific rendering helpers
     # ---------------------------------------------------------------------
@@ -417,21 +423,12 @@ class TUICommandRenderer:
             if image_path is not None:
                 self.display_image(str(image_path))
 
-        renderable = c_tools.render_tool_result(e, code_theme=self.themes.code_theme, session_id=e.session_id)
-        if renderable is not None:
-            self.print(renderable)
+        if not is_sub_agent and isinstance(e.ui_extra, model.ImageUIExtra):
+            self.display_image(e.ui_extra.file_path)
 
-    def display_thinking(self, content: str) -> None:
-        renderable = c_thinking.render_thinking(
-            content,
-            code_theme=self.themes.code_theme,
-            style=ThemeKey.THINKING,
-        )
+        renderable = c_tools.render_tool_result(e, code_theme=self.themes.code_theme, session_id=e.session_id)
         if renderable is not None:
-            self.console.push_theme(theme=self.themes.thinking_markdown_theme)
             self.print(renderable)
-            self.console.pop_theme()
-            self.print()
 
     def display_thinking_header(self, header: str) -> None:
         stripped = header.strip()
@@ -451,6 +448,13 @@ class TUICommandRenderer:
         with self.session_print_context(e.session_id):
             self.print(c_developer.render_developer_message(e))
 
+        # Display images from @ file references and user attachments
+        if e.item.ui_extra:
+            for ui_item in e.item.ui_extra.items:
+                if isinstance(ui_item, (model.AtFileImagesUIItem, model.UserImagesUIItem)):
+                    for image_path in ui_item.paths:
+                        self.display_image(image_path)
+
     def display_command_output(self, e: events.CommandOutputEvent) -> None:
         with self.session_print_context(e.session_id):
             self.print(c_command_output.render_command_output(e))
@@ -543,9 +547,9 @@ class TUICommandRenderer:
         )
         self.console.print(
             Rule(
-                Text("Context Compact", style=ThemeKey.COMPACTION_SUMMARY),
+                Text("Context Compacted", style=ThemeKey.COMPACTION_SUMMARY),
                 characters="=",
-                style=ThemeKey.COMPACTION_SUMMARY,
+                style=ThemeKey.LINES,
             )
         )
         self.print()
@@ -631,20 +635,31 @@ class TUICommandRenderer:
                     self.display_command_output(event)
                 case RenderTurnStart(event=event):
                     self.display_turn_start(event)
-                case StartThinkingStream():
-                    if not self._thinking_stream.is_active:
+                case StartThinkingStream(session_id=session_id):
+                    if self.is_sub_agent_session(session_id):
+                        self._sub_agent_thinking_buffers[session_id] = ""
+                    elif not self._thinking_stream.is_active:
                         self._thinking_stream.start(self._new_thinking_mdstream())
-                case AppendThinking(content=content):
-                    if self._thinking_stream.is_active:
+                case AppendThinking(session_id=session_id, content=content):
+                    if self.is_sub_agent_session(session_id):
+                        if session_id in self._sub_agent_thinking_buffers:
+                            self._sub_agent_thinking_buffers[session_id] += content
+                    elif self._thinking_stream.is_active:
                         first_delta = self._thinking_stream.buffer == ""
                         self._thinking_stream.append(content)
                         if first_delta:
                             self._thinking_stream.render(transform=c_thinking.normalize_thinking_content)
                         self._flush_thinking()
-                case EndThinkingStream():
-                    finalized = self._thinking_stream.finalize(transform=c_thinking.normalize_thinking_content)
-                    if finalized:
-                        self.print()
+                case EndThinkingStream(session_id=session_id):
+                    if self.is_sub_agent_session(session_id):
+                        buf = self._sub_agent_thinking_buffers.pop(session_id, "")
+                        if buf.strip():
+                            with self.session_print_context(session_id):
+                                self._render_sub_agent_thinking(buf)
+                    else:
+                        finalized = self._thinking_stream.finalize(transform=c_thinking.normalize_thinking_content)
+                        if finalized:
+                            self.print()
                 case StartAssistantStream():
                     if not self._assistant_stream.is_active:
                         self._assistant_stream.start(self._new_assistant_mdstream())
@@ -690,7 +705,7 @@ class TUICommandRenderer:
                 case PrintBlankLine():
                     self.print()
                 case PrintRuleLine():
-                    self.console.print(Rule(characters="─", style=ThemeKey.LINES))
+                    self.console.print(Rule(characters="─", style=ThemeKey.LINES_DIM))
                 case EmitOsc94Error():
                     emit_osc94(OSC94States.ERROR)
                 case EmitTmuxSignal():

klaude_code/tui/runner.py

@@ -327,5 +327,6 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
         if not exit_hint_printed:
             active_session_id = components.executor.context.current_session_id()
             if active_session_id and Session.exists(active_session_id):
+                short_id = Session.shortest_unique_prefix(active_session_id)
                 log(f"Session ID: {active_session_id}")
-                log(f"Resume with: klaude --resume {active_session_id}")
+                log(f"Resume with: klaude -r {short_id}")

klaude_code/tui/terminal/image.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import base64
 import shutil
-import struct
 import subprocess
 import sys
 import tempfile
@@ -12,12 +11,23 @@ from typing import IO
 # Kitty graphics protocol chunk size (4096 is the recommended max)
 _CHUNK_SIZE = 4096
 
-# Max columns for non-wide images
-_MAX_COLS = 120
+# Max columns for image display
+_MAX_COLS = 80
 
 # Image formats that need conversion to PNG
 _NEEDS_CONVERSION = {".jpg", ".jpeg", ".gif", ".bmp", ".webp", ".tiff", ".tif"}
 
+# Approximate pixels per terminal column (typical for most terminals)
+_PIXELS_PER_COL = 9
+
+
+def _get_png_width(data: bytes) -> int | None:
+    """Extract width from PNG header (IHDR chunk)."""
+    # PNG signature (8 bytes) + IHDR length (4 bytes) + "IHDR" (4 bytes) + width (4 bytes)
+    if len(data) < 24 or data[:8] != b"\x89PNG\r\n\x1a\n":
+        return None
+    return int.from_bytes(data[16:20], "big")
+
 
 def _convert_to_png(path: Path) -> bytes | None:
     """Convert image to PNG using sips (macOS) or convert (ImageMagick)."""
@@ -40,26 +50,10 @@ def _convert_to_png(path: Path) -> bytes | None:
     return None
 
 
-def _get_png_dimensions(data: bytes) -> tuple[int, int] | None:
-    """Extract width and height from PNG file header."""
-    # PNG: 8-byte signature + IHDR chunk (4 len + 4 type + 4 width + 4 height)
-    if len(data) < 24 or data[:8] != b"\x89PNG\r\n\x1a\n":
-        return None
-    width, height = struct.unpack(">II", data[16:24])
-    return width, height
-
-
 def print_kitty_image(file_path: str | Path, *, file: IO[str] | None = None) -> None:
     """Print an image to the terminal using Kitty graphics protocol.
 
-    This intentionally bypasses Rich rendering to avoid interleaving Live refreshes
-    with raw escape sequences. Image size adapts based on aspect ratio:
-    - Landscape images: fill terminal width
-    - Portrait images: limit height to avoid oversized display
-
-    Args:
-        file_path: Path to the image file (PNG recommended).
-        file: Output file stream. Defaults to stdout.
+    Only specifies column width; Kitty auto-scales height to preserve aspect ratio.
     """
     path = Path(file_path) if isinstance(file_path, str) else file_path
     if not path.exists():
@@ -80,20 +74,18 @@ def print_kitty_image(file_path: str | Path, *, file: IO[str] | None = None) ->
         out = file or sys.stdout
 
         term_size = shutil.get_terminal_size()
-        dimensions = _get_png_dimensions(data)
-
-        # Determine sizing strategy based on aspect ratio
-        if dimensions is not None:
-            img_width, img_height = dimensions
-            if img_width > 2 * img_height:
-                # Wide landscape (width > 2x height): fill terminal width
-                size_param = f"c={term_size.columns}"
-            else:
-                # Other images: limit width to 80% of terminal
-                size_param = f"c={min(_MAX_COLS, term_size.columns * 4 // 5)}"
+        target_cols = min(_MAX_COLS, term_size.columns)
+
+        # Only set column width if image is wider than target, to avoid upscaling small images
+        size_param = ""
+        img_width = _get_png_width(data)
+        if img_width is not None:
+            img_cols = img_width // _PIXELS_PER_COL
+            if img_cols > target_cols:
+                size_param = f"c={target_cols}"
         else:
-            # Fallback: limit width to 80% of terminal
-            size_param = f"c={min(_MAX_COLS, term_size.columns * 4 // 5)}"
+            # Fallback: always constrain if we can't determine image size
+            size_param = f"c={target_cols}"
         print("", file=out)
         _write_kitty_graphics(out, encoded, size_param=size_param)
         print("", file=out)
@@ -120,7 +112,8 @@ def _write_kitty_graphics(out: IO[str], encoded_data: str, *, size_param: str) -
 
         if i == 0:
             # First chunk: include control parameters
-            ctrl = f"a=T,f=100,{size_param},m={0 if is_last else 1}"
+            base_ctrl = f"a=T,f=100,{size_param}" if size_param else "a=T,f=100"
+            ctrl = f"{base_ctrl},m={0 if is_last else 1}"
             out.write(f"\033_G{ctrl};{chunk}\033\\")
         else:
             # Subsequent chunks: only m parameter needed

klaude_code/ui/common.py

@@ -1,17 +1,8 @@
-import re
-import subprocess
-from pathlib import Path
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from klaude_code.protocol.llm_param import LLMConfigModelParameter, OpenRouterProviderRouting
 
-LEADING_NEWLINES_REGEX = re.compile(r"^\n{2,}")
-
-
-def remove_leading_newlines(text: str) -> str:
-    return text.lstrip("\n")
-
 
 def format_number(tokens: int) -> str:
     if tokens < 1000:
@@ -33,67 +24,6 @@ def format_number(tokens: int) -> str:
             return f"{m}M{remaining}k"
 
 
-def get_current_git_branch(path: Path | None = None) -> str | None:
-    """Get current git branch name, return None if not in a git repository"""
-    if path is None:
-        path = Path.cwd()
-
-    try:
-        # Check if in git repository
-        git_dir = subprocess.run(
-            ["git", "rev-parse", "--git-dir"],
-            cwd=path,
-            capture_output=True,
-            text=True,
-            timeout=2,
-        )
-
-        if git_dir.returncode != 0:
-            return None
-
-        # Get current branch name
-        result = subprocess.run(
-            ["git", "branch", "--show-current"],
-            cwd=path,
-            capture_output=True,
-            text=True,
-            timeout=2,
-        )
-
-        if result.returncode == 0:
-            branch = result.stdout.strip()
-            return branch if branch else None
-
-        # Fallback: get HEAD reference
-        head_file = subprocess.run(
-            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
-            cwd=path,
-            capture_output=True,
-            text=True,
-            timeout=2,
-        )
-
-        if head_file.returncode == 0:
-            branch = head_file.stdout.strip()
-            return branch if branch and branch != "HEAD" else None
-
-    except (subprocess.TimeoutExpired, subprocess.SubprocessError, FileNotFoundError):
-        pass
-
-    return None
-
-
-def show_path_with_tilde(path: Path | None = None):
-    if path is None:
-        path = Path.cwd()
-
-    try:
-        relative_path = path.relative_to(Path.home())
-        return f"~/{relative_path}"
-    except ValueError:
-        return str(path)
-
-
 def format_model_params(model_params: "LLMConfigModelParameter") -> list[str]:
     """Format model parameters in a concise style.
 

{klaude_code-2.8.1.dist-info → klaude_code-2.9.1.dist-info}/METADATA

@@ -1,11 +1,12 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.8.1
+Version: 2.9.1
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0
 Requires-Dist: ddgs>=9.9.3
 Requires-Dist: diff-match-patch>=20241021
+Requires-Dist: filelock>=3.20.3
 Requires-Dist: google-genai>=1.56.0
 Requires-Dist: markdown-it-py>=4.0.0
 Requires-Dist: openai>=1.102.0
@@ -23,7 +24,7 @@ Description-Content-Type: text/markdown
 Minimal code agent CLI.
 
 ## Features
-- **Multi-provider**: Anthropic Message API, OpenAI Responses API, OpenRouter, Claude Max OAuth and ChatGPT Codex OAuth etc.
+- **Multi-provider**: Anthropic Message API, OpenAI Responses API, OpenRouter, ChatGPT Codex OAuth etc.
 - **Keep reasoning item in context**: Interleaved thinking support
 - **Model-aware tools**: Claude Code tool set for Opus, `apply_patch` for GPT-5/Codex
 - **Reminders**: Cooldown-based todo tracking, instruction reinforcement and external file change reminder
@@ -107,7 +108,6 @@ On first run, you'll be prompted to select a model. Your choice is saved as `mai
 | Provider    | Env Variable          | Models                                                                        |
 |-------------|-----------------------|-------------------------------------------------------------------------------|
 | anthropic   | `ANTHROPIC_API_KEY`   | sonnet, opus                                                                  |
-| claude      | N/A (OAuth)           | sonnet@claude, opus@claude (requires Claude Pro/Max subscription)             |
 | openai      | `OPENAI_API_KEY`      | gpt-5.2                                                                       |
 | openrouter  | `OPENROUTER_API_KEY`  | gpt-5.2, gpt-5.2-fast, gpt-5.1-codex-max, sonnet, opus, haiku, kimi, gemini-* |
 | deepseek    | `DEEPSEEK_API_KEY`    | deepseek                                                                      |
@@ -139,7 +139,6 @@ klaude auth login deepseek    # Set DEEPSEEK_API_KEY
 klaude auth login moonshot    # Set MOONSHOT_API_KEY
 
 # OAuth login for subscription-based providers
-klaude auth login claude      # Claude Pro/Max subscription
 klaude auth login codex       # ChatGPT Pro subscription
 ```
 
@@ -148,7 +147,6 @@ API keys are stored in `~/.klaude/klaude-auth.json` and used as fallback when en
 To logout from OAuth providers:
 
 ```bash
-klaude auth logout claude
 klaude auth logout codex
 ```
 
@@ -201,7 +199,6 @@ provider_list:
 ##### Supported Protocols
 
 - `anthropic` - Anthropic Messages API
-- `claude_oauth` - Claude OAuth (for Claude Pro/Max subscribers)
 - `openai` - OpenAI Chat Completion API
 - `responses` - OpenAI Responses API (for o-series, GPT-5, Codex)
 - `codex_oauth` - OpenAI Codex CLI (OAuth-based, for ChatGPT Pro subscribers)