klaude-code 2.9.0__py3-none-any.whl → 2.10.0__py3-none-any.whl

klaude_code/app/runtime.py

@@ -87,7 +87,7 @@ async def initialize_app_components(
     )
 
     if on_model_change is not None:
-        on_model_change(llm_clients.main.model_name)
+        on_model_change(llm_clients.main_model_alias)
 
     executor_task = asyncio.create_task(executor.start())
 

klaude_code/auth/antigravity/oauth.py

@@ -258,42 +258,46 @@ class AntigravityOAuth:
         )
 
     def refresh(self) -> AntigravityAuthState:
-        """Refresh the access token using refresh token."""
-        state = self.token_manager.get_state()
-        if state is None:
-            raise AntigravityNotLoggedInError("Not logged in to Antigravity. Run 'klaude login antigravity' first.")
+        """Refresh the access token using refresh token with file locking.
 
-        data = {
-            "client_id": CLIENT_ID,
-            "client_secret": CLIENT_SECRET,
-            "refresh_token": state.refresh_token,
-            "grant_type": "refresh_token",
-        }
+        Uses file locking to prevent multiple instances from refreshing simultaneously.
+        If another instance has already refreshed, returns the updated state.
+        """
 
-        with httpx.Client() as client:
-            response = client.post(TOKEN_URL, data=data, timeout=30)
+        def do_refresh(current_state: AntigravityAuthState) -> AntigravityAuthState:
+            data = {
+                "client_id": CLIENT_ID,
+                "client_secret": CLIENT_SECRET,
+                "refresh_token": current_state.refresh_token,
+                "grant_type": "refresh_token",
+            }
 
-        if response.status_code != 200:
-            raise AntigravityTokenExpiredError(f"Token refresh failed: {response.text}")
+            with httpx.Client() as client:
+                response = client.post(TOKEN_URL, data=data, timeout=30)
 
-        tokens = response.json()
-        access_token = tokens["access_token"]
-        refresh_token = tokens.get("refresh_token", state.refresh_token)
-        expires_in = tokens.get("expires_in", 3600)
+            if response.status_code != 200:
+                raise AntigravityTokenExpiredError(f"Token refresh failed: {response.text}")
 
-        # Calculate expiry time with 5 minute buffer
-        expires_at = int(time.time()) + expires_in - 300
+            tokens = response.json()
+            access_token = tokens["access_token"]
+            refresh_token = tokens.get("refresh_token", current_state.refresh_token)
+            expires_in = tokens.get("expires_in", 3600)
 
-        new_state = AntigravityAuthState(
-            access_token=access_token,
-            refresh_token=refresh_token,
-            expires_at=expires_at,
-            project_id=state.project_id,
-            email=state.email,
-        )
+            # Calculate expiry time with 5 minute buffer
+            expires_at = int(time.time()) + expires_in - 300
+
+            return AntigravityAuthState(
+                access_token=access_token,
+                refresh_token=refresh_token,
+                expires_at=expires_at,
+                project_id=current_state.project_id,
+                email=current_state.email,
+            )
 
-        self.token_manager.save(new_state)
-        return new_state
+        try:
+            return self.token_manager.refresh_with_lock(do_refresh)
+        except ValueError as e:
+            raise AntigravityNotLoggedInError(str(e)) from e
 
     def ensure_valid_token(self) -> tuple[str, str]:
         """Ensure we have a valid access token, refreshing if needed.

klaude_code/auth/claude/oauth.py

@@ -125,60 +125,45 @@ class ClaudeOAuth:
             expires_at=int(time.time()) + int(expires_in),
         )
 
-    def _do_refresh_request(self, refresh_token: str) -> httpx.Response:
-        """Send token refresh request to OAuth server."""
-        payload = {
-            "grant_type": "refresh_token",
-            "client_id": CLIENT_ID,
-            "refresh_token": refresh_token,
-        }
-        with httpx.Client() as client:
-            return client.post(
-                TOKEN_URL,
-                json=payload,
-                headers={"Content-Type": "application/json"},
-            )
-
     def refresh(self) -> ClaudeAuthState:
-        """Refresh the access token using refresh token.
+        """Refresh the access token using refresh token with file locking.
 
-        Handles concurrent refresh race conditions by retrying with freshly loaded token
-        if the first attempt fails with invalid_grant error.
+        Uses file locking to prevent multiple instances from refreshing simultaneously.
+        If another instance has already refreshed, returns the updated state.
         """
-        state = self.token_manager.get_state()
-        if state is None:
-            raise ClaudeNotLoggedInError("Not logged in to Claude. Run 'klaude login claude' first.")
 
-        response = self._do_refresh_request(state.refresh_token)
-
-        # Handle race condition: another process may have refreshed the token already
-        if response.status_code != 200 and "invalid_grant" in response.text:
-            # Reload token from file (another process may have updated it)
-            self.token_manager.clear_cached_state()
-            fresh_state = self.token_manager.load()
-            if fresh_state and fresh_state.refresh_token != state.refresh_token:
-                # Token was updated by another process
-                if not fresh_state.is_expired():
-                    # New token is still valid, use it directly
-                    return fresh_state
-                # New token expired, try refreshing with the new refresh_token
-                response = self._do_refresh_request(fresh_state.refresh_token)
-
-        if response.status_code != 200:
-            raise ClaudeAuthError(f"Token refresh failed: {response.text}")
-
-        tokens = response.json()
-        access_token = tokens["access_token"]
-        refresh_token = tokens.get("refresh_token", state.refresh_token)
-        expires_in = tokens.get("expires_in", 3600)
+        def do_refresh(current_state: ClaudeAuthState) -> ClaudeAuthState:
+            payload = {
+                "grant_type": "refresh_token",
+                "client_id": CLIENT_ID,
+                "refresh_token": current_state.refresh_token,
+            }
+
+            with httpx.Client() as client:
+                response = client.post(
+                    TOKEN_URL,
+                    json=payload,
+                    headers={"Content-Type": "application/json"},
+                )
+
+            if response.status_code != 200:
+                raise ClaudeAuthError(f"Token refresh failed: {response.text}")
+
+            tokens = response.json()
+            access_token = tokens["access_token"]
+            refresh_token = tokens.get("refresh_token", current_state.refresh_token)
+            expires_in = tokens.get("expires_in", 3600)
+
+            return ClaudeAuthState(
+                access_token=access_token,
+                refresh_token=refresh_token,
+                expires_at=int(time.time()) + int(expires_in),
+            )
 
-        new_state = ClaudeAuthState(
-            access_token=access_token,
-            refresh_token=refresh_token,
-            expires_at=int(time.time()) + int(expires_in),
-        )
-        self.token_manager.save(new_state)
-        return new_state
+        try:
+            return self.token_manager.refresh_with_lock(do_refresh)
+        except ValueError as e:
+            raise ClaudeNotLoggedInError(str(e)) from e
 
     def ensure_valid_token(self) -> str:
         """Ensure we have a valid access token, refreshing if needed."""

klaude_code/cli/cost_cmd.py

@@ -343,7 +343,7 @@ def render_cost_table(daily_stats: dict[str, DailyStats]) -> Table:
                 sub_list = list(group.sub_providers.values())
                 for sub_idx, sub_group in enumerate(sub_list):
                     is_last_sub = sub_idx == len(sub_list) - 1
-                    sub_prefix = " └─ " if is_last_sub else " ├─ "
+                    sub_prefix = " ╰─ " if is_last_sub else " ├─ "
 
                     # Sub-provider row
                     add_stats_row(sub_group.total, prefix=sub_prefix, bold=True)
@@ -353,15 +353,15 @@ def render_cost_table(daily_stats: dict[str, DailyStats]) -> Table:
                         is_last_model = model_idx == len(sub_group.models) - 1
                         # Indent based on whether sub-provider is last
                         if is_last_sub:
-                            model_prefix = "     └─ " if is_last_model else "     ├─ "
+                            model_prefix = "     ╰─ " if is_last_model else "     ├─ "
                         else:
-                            model_prefix = " │   └─ " if is_last_model else " │   ├─ "
+                            model_prefix = " │   ╰─ " if is_last_model else " │   ├─ "
                         add_stats_row(stats, prefix=model_prefix)
             else:
                 # No sub-providers: render two-level tree (direct models)
                 for model_idx, stats in enumerate(group.models):
                     is_last_model = model_idx == len(group.models) - 1
-                    model_prefix = " └─ " if is_last_model else " ├─ "
+                    model_prefix = " ╰─ " if is_last_model else " ├─ "
                     add_stats_row(stats, prefix=model_prefix)
 
         if show_subtotal:

klaude_code/cli/list_model.py

@@ -338,7 +338,7 @@ def _build_models_table(
     model_count = len(provider.model_list)
     for i, model in enumerate(provider.model_list):
         is_last = i == model_count - 1
-        prefix = " └─ " if is_last else " ├─ "
+        prefix = " ╰─ " if is_last else " ├─ "
 
         if provider_disabled:
             name = Text.assemble(
@@ -439,7 +439,6 @@ def display_models_and_providers(config: Config, *, show_all: bool = False):
         # Provider info panel
         provider_panel = _build_provider_info_panel(provider, provider_available, disabled=provider.disabled)
         console.print(provider_panel)
-        console.print()
 
         # Models table for this provider
         models_table = _build_models_table(provider, config)

klaude_code/config/assets/builtin_config.yaml

@@ -148,6 +148,8 @@ provider_list:
     modalities:
     - image
     - text
+    image_config:
+      image_size: "4K"
     cost: {input: 2, output: 12, cache_read: 0.2, image: 120}
 
   - model_name: nano-banana
@@ -221,6 +223,8 @@ provider_list:
     modalities:
     - image
     - text
+    image_config:
+      image_size: "4K"
     cost: {input: 2, output: 12, cache_read: 0.2, image: 120}
 
   - model_name: nano-banana
@@ -275,6 +279,19 @@ provider_list:
     cost: {input: 4, output: 16, cache_read: 1, currency: CNY}
 
 
+- provider_name: cerebras
+  protocol: openai
+  api_key: ${CEREBRAS_API_KEY}
+  base_url: https://api.cerebras.ai/v1
+  model_list:
+
+  - model_name: glm
+    model_id: zai-glm-4.7
+    context_limit: 131072
+    max_tokens: 12800
+    cost: {input: 2.25, output: 2.75}
+
+
 - provider_name: claude-max
   protocol: claude_oauth
   disabled: true

klaude_code/const.py

@@ -71,7 +71,6 @@ DEFAULT_ANTHROPIC_THINKING_BUDGET_TOKENS = 2048  # Default thinking budget token
 
 TODO_REMINDER_TOOL_CALL_THRESHOLD = 10  # Tool call count threshold for todo reminder
 REMINDER_COOLDOWN_TURNS = 3  # Cooldown turns between reminder triggers
-MEMORY_FILE_NAMES = ["CLAUDE.md", "AGENTS.md", "AGENT.md"]  # Memory file names to search for
 
 
 # =============================================================================
@@ -92,6 +91,7 @@ BINARY_CHECK_SIZE = 8192  # Bytes to check for binary file detection
 
 BASH_DEFAULT_TIMEOUT_MS = 120000  # Default timeout for bash commands (milliseconds)
 BASH_TERMINATE_TIMEOUT_SEC = 1.0  # Timeout before escalating to SIGKILL (seconds)
+BASH_MODE_SESSION_OUTPUT_MAX_BYTES = 200 * 1024 * 1024  # Max command output captured for session history
 
 
 # =============================================================================
@@ -156,8 +156,8 @@ CROP_ABOVE_LIVE_REFRESH_PER_SECOND = 4.0  # CropAboveLive default refresh rate
 MARKDOWN_STREAM_LIVE_REPAINT_ENABLED = True  # Enable live area for streaming markdown
 MARKDOWN_STREAM_SYNCHRONIZED_OUTPUT_ENABLED = True  # Use terminal "Synchronized Output" to reduce flicker
 STREAM_MAX_HEIGHT_SHRINK_RESET_LINES = 20  # Reset stream height ceiling after this shrinkage
-MARKDOWN_LEFT_MARGIN = 2  # Left margin (columns) for markdown rendering
-MARKDOWN_RIGHT_MARGIN = 2  # Right margin (columns) for markdown rendering
+MARKDOWN_LEFT_MARGIN = 0  # Left margin (columns) for markdown rendering
+MARKDOWN_RIGHT_MARGIN = 0  # Right margin (columns) for markdown rendering
 
 
 # =============================================================================
@@ -171,6 +171,7 @@ STATUS_WAITING_TEXT = "Loading …"
 STATUS_THINKING_TEXT = "Thinking …"
 STATUS_COMPOSING_TEXT = "Composing"
 STATUS_COMPACTING_TEXT = "Compacting"
+STATUS_RUNNING_TEXT = "Running …"
 
 # Backwards-compatible alias for the default spinner status text.
 STATUS_DEFAULT_TEXT = STATUS_WAITING_TEXT

klaude_code/core/agent_profile.py

@@ -132,7 +132,7 @@ def load_system_prompt(
 
     # For codex_oauth protocol, use dynamic prompts from GitHub (no additions).
     if protocol == llm_param.LLMClientProtocol.CODEX_OAUTH:
-        from klaude_code.llm.codex.prompt_sync import get_codex_instructions
+        from klaude_code.llm.openai_codex.prompt_sync import get_codex_instructions
 
         return get_codex_instructions(model_name)
 
@@ -176,8 +176,6 @@ def load_agent_tools(
     # Main agent tools
     if "gpt-5" in model_name:
         tool_names: list[str] = [tools.BASH, tools.READ, tools.APPLY_PATCH, tools.UPDATE_PLAN]
-    elif "gemini-3" in model_name:
-        tool_names = [tools.BASH, tools.READ, tools.EDIT, tools.WRITE]
     else:
         tool_names = [tools.BASH, tools.READ, tools.EDIT, tools.WRITE, tools.TODO_WRITE]
 
@@ -189,8 +187,7 @@ def load_agent_tools(
     else:
         tool_names.append(tools.IMAGE_GEN)
 
-    tool_names.extend([tools.MERMAID])
-    # tool_names.extend([tools.MEMORY])
+    tool_names.append(tools.MERMAID)
     return get_tool_schemas(tool_names)
 
 

klaude_code/core/bash_mode.py

@@ -0,0 +1,276 @@
+"""Bash-mode execution helpers.
+
+This module provides the implementation for running non-interactive shell commands
+with streaming output to the UI, plus session history recording.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import os
+import re
+import secrets
+import shutil
+import signal
+import subprocess
+import sys
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TextIO
+
+from klaude_code.const import BASH_MODE_SESSION_OUTPUT_MAX_BYTES, BASH_TERMINATE_TIMEOUT_SEC, TOOL_OUTPUT_TRUNCATION_DIR
+from klaude_code.core.tool.offload import offload_tool_output
+from klaude_code.protocol import events, message
+from klaude_code.session.session import Session
+
+
+@dataclass(frozen=True)
+class _BashModeToolCall:
+    tool_name: str = "Bash"
+
+
+_ANSI_ESCAPE_RE = re.compile(
+    r"""
+    \x1B
+    (?:
+        \[[0-?]*[ -/]*[@-~]         |  # CSI sequences
+        \][0-?]*.*?(?:\x07|\x1B\\) |  # OSC sequences
+        P.*?(?:\x07|\x1B\\)       |  # DCS sequences
+        _.*?(?:\x07|\x1B\\)       |  # APC sequences
+        \^.*?(?:\x07|\x1B\\)      |  # PM sequences
+        [@-Z\\-_]                      # 2-char sequences
+    )
+    """,
+    re.VERBOSE | re.DOTALL,
+)
+
+
+def _format_inline_code(text: str) -> str:
+    if not text:
+        return "``"
+    max_run = 0
+    run = 0
+    for ch in text:
+        if ch == "`":
+            run += 1
+            max_run = max(max_run, run)
+        else:
+            run = 0
+    fence = "`" * (max_run + 1)
+    return f"{fence}{text}{fence}"
+
+
+def _resolve_shell_command(command_text: str) -> list[str]:
+    # Use the user's default shell when possible.
+    # - macOS/Linux: $SHELL (supports bash/zsh/fish)
+    # - Windows: prefer pwsh/powershell
+    if sys.platform == "win32":  # pragma: no cover
+        exe = "pwsh" if shutil.which("pwsh") else "powershell"
+        return [exe, "-NoProfile", "-Command", command_text]
+
+    shell_path = os.environ.get("SHELL")
+    shell_name = Path(shell_path).name.lower() if shell_path else ""
+    if shell_path and shell_name in {"bash", "zsh", "fish"}:
+        # Use -lic to load both login profile and interactive config (e.g. aliases from .zshrc)
+        return [shell_path, "-lic", command_text]
+    return ["bash", "-lic", command_text]
+
+
+async def _terminate_process(proc: asyncio.subprocess.Process) -> None:
+    if proc.returncode is not None:
+        return
+
+    try:
+        if os.name == "posix":
+            os.killpg(proc.pid, signal.SIGTERM)
+        else:  # pragma: no cover
+            proc.terminate()
+    except ProcessLookupError:
+        return
+    except OSError:
+        pass
+
+    with contextlib.suppress(Exception):
+        await asyncio.wait_for(proc.wait(), timeout=BASH_TERMINATE_TIMEOUT_SEC)
+        return
+
+    with contextlib.suppress(Exception):
+        if os.name == "posix":
+            os.killpg(proc.pid, signal.SIGKILL)
+        else:  # pragma: no cover
+            proc.kill()
+    with contextlib.suppress(Exception):
+        await asyncio.wait_for(proc.wait(), timeout=BASH_TERMINATE_TIMEOUT_SEC)
+
+
+async def _emit_clean_chunk(
+    *,
+    emit_event: Callable[[events.Event], Awaitable[None]],
+    session_id: str,
+    chunk: str,
+    out_file: TextIO,
+) -> None:
+    if not chunk:
+        return
+
+    cleaned = _ANSI_ESCAPE_RE.sub("", chunk)
+    if cleaned:
+        await emit_event(events.BashCommandOutputDeltaEvent(session_id=session_id, content=cleaned))
+        with contextlib.suppress(Exception):
+            out_file.write(cleaned)
+
+
+async def run_bash_command(
+    *,
+    emit_event: Callable[[events.Event], Awaitable[None]],
+    session: Session,
+    session_id: str,
+    command: str,
+) -> None:
+    """Run a non-interactive bash command with streaming output to the UI.
+
+    The full (cleaned) output is appended to session history in a single UserMessage
+    as: `Ran <command>` plus truncated output via offload strategy.
+    """
+
+    await emit_event(events.BashCommandStartEvent(session_id=session_id, command=command))
+
+    # Create a log file to support large outputs without holding everything in memory.
+    # Use TOOL_OUTPUT_TRUNCATION_DIR (system temp) for consistency with offload.
+    tmp_root = Path(TOOL_OUTPUT_TRUNCATION_DIR)
+    tmp_root.mkdir(parents=True, exist_ok=True)
+    log_path = tmp_root / f"klaude-bash-mode-{secrets.token_hex(8)}.log"
+
+    env = os.environ.copy()
+    env.update(
+        {
+            "GIT_TERMINAL_PROMPT": "0",
+            "PAGER": "cat",
+            "GIT_PAGER": "cat",
+            "EDITOR": "true",
+            "VISUAL": "true",
+            "GIT_EDITOR": "true",
+            "JJ_EDITOR": "true",
+            "TERM": "dumb",
+        }
+    )
+
+    proc: asyncio.subprocess.Process | None = None
+    cancelled = False
+    exit_code: int | None = None
+
+    # Hold back any trailing ESC-started sequence to avoid leaking control codes
+    # when the subprocess output is chunked.
+    pending = ""
+
+    try:
+        kwargs: dict[str, object] = {
+            "stdin": asyncio.subprocess.DEVNULL,
+            "stdout": asyncio.subprocess.PIPE,
+            "stderr": asyncio.subprocess.STDOUT,
+            "env": env,
+        }
+        if os.name == "posix":
+            kwargs["start_new_session"] = True
+        elif os.name == "nt":  # pragma: no cover
+            kwargs["creationflags"] = getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)
+
+        shell_argv = _resolve_shell_command(command)
+        proc = await asyncio.create_subprocess_exec(*shell_argv, **kwargs)  # type: ignore[arg-type]
+        assert proc.stdout is not None
+
+        with log_path.open("w", encoding="utf-8", errors="replace") as out_file:
+            while True:
+                data = await proc.stdout.read(4096)
+                if not data:
+                    break
+                piece = data.decode(errors="replace")
+                pending += piece
+
+                # Keep from the last ESC onwards to avoid emitting incomplete sequences.
+                last_esc = pending.rfind("\x1b")
+                if last_esc == -1:
+                    to_emit, pending = pending, ""
+                elif last_esc < len(pending) - 128:
+                    to_emit, pending = pending[:last_esc], pending[last_esc:]
+                else:
+                    # Wait for more bytes to complete the sequence.
+                    continue
+
+                await _emit_clean_chunk(
+                    emit_event=emit_event,
+                    session_id=session_id,
+                    chunk=to_emit,
+                    out_file=out_file,
+                )
+
+            if pending:
+                await _emit_clean_chunk(
+                    emit_event=emit_event,
+                    session_id=session_id,
+                    chunk=pending,
+                    out_file=out_file,
+                )
+                pending = ""
+
+        exit_code = await proc.wait()
+
+    except asyncio.CancelledError:
+        cancelled = True
+        if proc is not None:
+            with contextlib.suppress(Exception):
+                await asyncio.shield(_terminate_process(proc))
+    except Exception as exc:
+        # Surface errors to the UI as a final line.
+        msg = f"Execution error: {exc.__class__.__name__} {exc}"
+        await emit_event(events.BashCommandOutputDeltaEvent(session_id=session_id, content=msg))
+    finally:
+        header = f"Ran {_format_inline_code(command)}"
+
+        record_lines: list[str] = [header]
+        if cancelled:
+            record_lines.append("\n(command cancelled)")
+        elif isinstance(exit_code, int) and exit_code != 0:
+            record_lines.append(f"\nCommand exited with code {exit_code}")
+
+        output_text = ""
+        output_note_added = False
+        try:
+            if log_path.exists() and log_path.stat().st_size > BASH_MODE_SESSION_OUTPUT_MAX_BYTES:
+                record_lines.append(
+                    f"\n\n<system-reminder>Output truncated due to length. Full output saved to: {log_path} </system-reminder>"
+                )
+                output_note_added = True
+            else:
+                output_text = log_path.read_text("utf-8", errors="replace") if log_path.exists() else ""
+        except OSError:
+            output_text = ""
+
+        if output_text.strip() == "":
+            if not cancelled and not output_note_added:
+                record_lines.append("\n(no output)")
+                await emit_event(events.BashCommandOutputDeltaEvent(session_id=session_id, content="(no output)\n"))
+        else:
+            offloaded = offload_tool_output(output_text, _BashModeToolCall())
+            record_lines.append("\n\n" + offloaded.output)
+
+        # Always emit an end event so the renderer can finalize formatting.
+        await emit_event(
+            events.BashCommandEndEvent(
+                session_id=session_id,
+                exit_code=exit_code,
+                cancelled=cancelled,
+            )
+        )
+        session.append_history(
+            [
+                message.UserMessage(
+                    parts=message.parts_from_text_and_images(
+                        "".join(record_lines).rstrip(),
+                        None,
+                    )
+                )
+            ]
+        )