klaude-code 2.10.1__tar.gz → 2.10.2__tar.gz

{klaude_code-2.10.1 → klaude_code-2.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.10.1
+Version: 2.10.2
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0

{klaude_code-2.10.1 → klaude_code-2.10.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "2.10.1"
+version = "2.10.2"
 description = "Minimal code agent CLI"
 readme = "README.md"
 requires-python = ">=3.13"

{klaude_code-2.10.1 → klaude_code-2.10.2}/src/klaude_code/core/agent_profile.py

@@ -130,12 +130,6 @@ def load_system_prompt(
 ) -> str:
     """Get system prompt content for the given model and sub-agent type."""
 
-    # For codex_oauth protocol, use dynamic prompts from GitHub (no additions).
-    if protocol == llm_param.LLMClientProtocol.CODEX_OAUTH:
-        from klaude_code.llm.openai_codex.prompt_sync import get_codex_instructions
-
-        return get_codex_instructions(model_name)
-
     # For antigravity protocol, use exact prompt without any additions.
     if protocol == llm_param.LLMClientProtocol.ANTIGRAVITY:
         return _load_prompt_by_path(ANTIGRAVITY_PROMPT_PATH)

{klaude_code-2.10.1 → klaude_code-2.10.2}/src/klaude_code/llm/openai_codex/client.py

@@ -146,28 +146,6 @@ class CodexClient(LLMClientABC):
             )
         except (openai.OpenAIError, httpx.HTTPError) as e:
             error_message = f"{e.__class__.__name__} {e!s}"
-
-            # Check for invalid instruction error and invalidate prompt cache
-            if _is_invalid_instruction_error(e) and param.model_id:
-                _invalidate_prompt_cache_for_model(param.model_id)
-
             return error_llm_stream(metadata_tracker, error=error_message)
 
         return ResponsesLLMStream(stream, param=param, metadata_tracker=metadata_tracker)
-
-
-def _is_invalid_instruction_error(e: Exception) -> bool:
-    """Check if the error is related to invalid instructions."""
-    error_str = str(e).lower()
-    return "invalid instruction" in error_str or "invalid_instruction" in error_str
-
-
-def _invalidate_prompt_cache_for_model(model_id: str) -> None:
-    """Invalidate the cached prompt for a model to force refresh."""
-    from klaude_code.llm.openai_codex.prompt_sync import invalidate_cache
-
-    log_debug(
-        f"Invalidating prompt cache for model {model_id} due to invalid instruction error",
-        debug_type=DebugType.GENERAL,
-    )
-    invalidate_cache(model_id)

{klaude_code-2.10.1 → klaude_code-2.10.2}/src/klaude_code/llm/openrouter/client.py

@@ -17,7 +17,7 @@ from klaude_code.llm.client import LLMClientABC, LLMStreamABC
 from klaude_code.llm.input_common import apply_config_defaults
 from klaude_code.llm.openai_compatible.input import convert_tool_schema
 from klaude_code.llm.openai_compatible.stream import OpenAILLMStream
-from klaude_code.llm.openrouter.input import convert_history_to_input, is_claude_model
+from klaude_code.llm.openrouter.input import convert_history_to_input, is_claude_model, is_xai_model
 from klaude_code.llm.openrouter.reasoning import ReasoningStreamHandler
 from klaude_code.llm.registry import register
 from klaude_code.llm.usage import MetadataTracker, error_llm_stream
@@ -70,6 +70,9 @@ def build_payload(
             f"{ANTHROPIC_BETA_FINE_GRAINED_TOOL_STREAMING},{ANTHROPIC_BETA_INTERLEAVED_THINKING}"
         )
 
+    if is_xai_model(param.model_id):
+        extra_body["plugins"] = [{"id": "web", "engine": "native"}]
+
     payload: CompletionCreateParamsStreaming = {
         "model": str(param.model_id),
         "tool_choice": "auto",

{klaude_code-2.10.1 → klaude_code-2.10.2}/src/klaude_code/llm/openrouter/input.py

@@ -34,6 +34,12 @@ def is_gemini_model(model_name: str | None) -> bool:
     return model_name is not None and model_name.startswith("google/gemini")
 
 
+def is_xai_model(model_name: str | None) -> bool:
+    """Return True if the model name represents an xAI model."""
+
+    return model_name is not None and model_name.startswith("x-ai/")
+
+
 def _assistant_message_to_openrouter(
     msg: message.AssistantMessage, model_name: str | None
 ) -> chat.ChatCompletionMessageParam:

{klaude_code-2.10.1 → klaude_code-2.10.2}/src/klaude_code/tui/input/key_bindings.py

@@ -76,6 +76,60 @@ def create_key_bindings(
     term_program = os.environ.get("TERM_PROGRAM", "").lower()
     swallow_next_control_j = False
 
+    def _history_backward_cursor_to_start(buf: Buffer) -> None:
+        """Switch to previous history entry and place cursor at absolute start.
+
+        prompt_toolkit's default `Buffer.history_backward()` moves the cursor to
+        the end of the (possibly multi-line) history entry. That makes it hard
+        to keep pressing Up to continue cycling history, because subsequent Up
+        key presses start moving within the multi-line buffer.
+        """
+
+        try:
+            before = int(buf.working_index)  # type: ignore[reportUnknownMemberType]
+        except Exception:
+            before = None
+
+        buf.history_backward()
+
+        try:
+            after = int(buf.working_index)  # type: ignore[reportUnknownMemberType]
+        except Exception:
+            after = None
+
+        if before is not None and after is not None and before == after:
+            return
+
+        with contextlib.suppress(Exception):
+            buf.cursor_position = 0  # type: ignore[reportUnknownMemberType]
+
+    def _history_forward_cursor_to_end(buf: Buffer) -> None:
+        """Switch to next history entry and place cursor at absolute end.
+
+        prompt_toolkit's default `Buffer.history_forward()` moves the cursor to
+        the end of the *first* line. For our multiline REPL, it's more useful to
+        land at the end so that pressing Down keeps cycling through history.
+        """
+
+        try:
+            before = int(buf.working_index)  # type: ignore[reportUnknownMemberType]
+        except Exception:
+            before = None
+
+        buf.history_forward()
+
+        try:
+            after = int(buf.working_index)  # type: ignore[reportUnknownMemberType]
+        except Exception:
+            after = None
+
+        if before is not None and after is not None and before == after:
+            return
+
+        with contextlib.suppress(Exception):
+            text = buf.text  # type: ignore[reportUnknownMemberType]
+            buf.cursor_position = len(text)  # type: ignore[reportUnknownMemberType]
+
     def _is_bash_mode_text(text: str) -> bool:
         return text.startswith(("!", "！"))
 
@@ -151,6 +205,20 @@ def create_key_bindings(
         except Exception:
             return False
 
+    def _current_cursor_row() -> int:
+        try:
+            doc = get_app().current_buffer.document
+            return int(doc.cursor_position_row)
+        except Exception:
+            return 0
+
+    def _current_line_count() -> int:
+        try:
+            doc = get_app().current_buffer.document
+            return int(doc.line_count)
+        except Exception:
+            return 1
+
     def _move_cursor_visually_within_wrapped_line(event: KeyPressEvent, *, delta_visible_y: int) -> None:
         """Move the cursor Up/Down by one wrapped screen row, keeping column."""
 
@@ -493,6 +561,32 @@ def create_key_bindings(
     def _(event: KeyPressEvent) -> None:
         _move_cursor_visually_within_wrapped_line(event, delta_visible_y=1)
 
+    @kb.add(
+        "up",
+        filter=enabled
+        & ~has_completions
+        & ~is_searching
+        & Condition(lambda: not _can_move_cursor_visually_within_wrapped_line(delta_visible_y=-1))
+        & Condition(lambda: _current_cursor_row() == 0),
+        eager=True,
+    )
+    def _(event: KeyPressEvent) -> None:
+        """Up on first logical line: switch history and keep caret at start."""
+        _history_backward_cursor_to_start(event.current_buffer)
+
+    @kb.add(
+        "down",
+        filter=enabled
+        & ~has_completions
+        & ~is_searching
+        & Condition(lambda: not _can_move_cursor_visually_within_wrapped_line(delta_visible_y=1))
+        & Condition(lambda: _current_cursor_row() >= (_current_line_count() - 1)),
+        eager=True,
+    )
+    def _(event: KeyPressEvent) -> None:
+        """Down on last logical line: switch history and keep caret at end."""
+        _history_forward_cursor_to_end(event.current_buffer)
+
     @kb.add("c-j", filter=enabled)
     def _(event: KeyPressEvent) -> None:
         nonlocal swallow_next_control_j
@@ -617,11 +711,11 @@ def create_key_bindings(
     @kb.add("escape", "up", filter=enabled & ~has_completions)
     def _(event: KeyPressEvent) -> None:
         """Option+Up switches to previous history entry."""
-        event.current_buffer.history_backward()
+        _history_backward_cursor_to_start(event.current_buffer)
 
     @kb.add("escape", "down", filter=enabled & ~has_completions)
     def _(event: KeyPressEvent) -> None:
         """Option+Down switches to next history entry."""
-        event.current_buffer.history_forward()
+        _history_forward_cursor_to_end(event.current_buffer)
 
     return kb

{klaude_code-2.10.1 → klaude_code-2.10.2}/src/klaude_code/tui/machine.py

@@ -736,6 +736,7 @@ class DisplayStateMachine:
                     and not e.has_structured_output
                     and s.assistant_char_count == 0
                     and e.task_result.strip()
+                    and e.task_result.strip().lower() not in {"task cancelled", "task canceled"}
                 ):
                     cmds.append(StartAssistantStream(session_id=e.session_id))
                     cmds.append(AppendAssistant(session_id=e.session_id, content=e.task_result))

{klaude_code-2.10.1 → klaude_code-2.10.2}/src/klaude_code/tui/renderer.py

@@ -734,6 +734,9 @@ class TUICommandRenderer:
                         self._sub_agent_thinking_buffers[session_id] = ""
                     elif not self._thinking_stream.is_active:
                         self._thinking_stream.start(self._new_thinking_mdstream())
+                        if not self._replay_mode:
+                            self._thinking_stream.append("Thinking…  \n")
+                            self._thinking_stream.render(transform=c_thinking.normalize_thinking_content)
                 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:

klaude_code-2.10.1/src/klaude_code/llm/openai_codex/prompt_sync.py

@@ -1,237 +0,0 @@
-"""Dynamic prompt synchronization from OpenAI Codex GitHub repository."""
-
-import json
-import time
-from functools import cache
-from importlib.resources import files
-from pathlib import Path
-from typing import Any, Literal
-
-import httpx
-
-from klaude_code.log import DebugType, log_debug
-
-GITHUB_API_RELEASES = "https://api.github.com/repos/openai/codex/releases/latest"
-GITHUB_HTML_RELEASES = "https://github.com/openai/codex/releases/latest"
-GITHUB_RAW_BASE = "https://raw.githubusercontent.com/openai/codex"
-
-CACHE_DIR = Path.home() / ".klaude" / "codex-prompts"
-CACHE_TTL_SECONDS = 24 * 60 * 60  # 24 hours
-
-type ModelFamily = Literal["gpt-5.2-codex", "codex-max", "codex", "gpt-5.2", "gpt-5.1"]
-
-PROMPT_FILES: dict[ModelFamily, str] = {
-    "gpt-5.2-codex": "gpt-5.2-codex_prompt.md",
-    "codex-max": "gpt-5.1-codex-max_prompt.md",
-    "codex": "gpt_5_codex_prompt.md",
-    "gpt-5.2": "gpt_5_2_prompt.md",
-    "gpt-5.1": "gpt_5_1_prompt.md",
-}
-
-CACHE_FILES: dict[ModelFamily, str] = {
-    "gpt-5.2-codex": "gpt-5.2-codex-instructions.md",
-    "codex-max": "codex-max-instructions.md",
-    "codex": "codex-instructions.md",
-    "gpt-5.2": "gpt-5.2-instructions.md",
-    "gpt-5.1": "gpt-5.1-instructions.md",
-}
-
-
-@cache
-def _load_bundled_prompt(prompt_path: str) -> str:
-    """Load bundled prompt from package resources."""
-    return files("klaude_code.core").joinpath(prompt_path).read_text(encoding="utf-8").strip()
-
-
-class CacheMetadata:
-    def __init__(self, etag: str | None, tag: str, last_checked: int, url: str):
-        self.etag = etag
-        self.tag = tag
-        self.last_checked = last_checked
-        self.url = url
-
-    def to_dict(self) -> dict[str, str | int | None]:
-        return {
-            "etag": self.etag,
-            "tag": self.tag,
-            "last_checked": self.last_checked,
-            "url": self.url,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict[str, object]) -> "CacheMetadata":
-        etag = data.get("etag")
-        last_checked = data.get("last_checked")
-        return cls(
-            etag=etag if isinstance(etag, str) else None,
-            tag=str(data.get("tag", "")),
-            last_checked=int(last_checked) if isinstance(last_checked, int | float) else 0,
-            url=str(data.get("url", "")),
-        )
-
-
-def get_model_family(model: str) -> ModelFamily:
-    """Determine model family from model name."""
-    if "gpt-5.2-codex" in model or "gpt 5.2 codex" in model:
-        return "gpt-5.2-codex"
-    if "codex-max" in model:
-        return "codex-max"
-    if "codex" in model or model.startswith("codex-"):
-        return "codex"
-    if "gpt-5.2" in model:
-        return "gpt-5.2"
-    return "gpt-5.1"
-
-
-def _get_latest_release_tag(client: httpx.Client) -> str:
-    """Get latest release tag from GitHub."""
-    try:
-        response = client.get(GITHUB_API_RELEASES)
-        if response.status_code == 200:
-            data: dict[str, Any] = response.json()
-            tag_name: Any = data.get("tag_name")
-            if isinstance(tag_name, str):
-                return tag_name
-    except httpx.HTTPError:
-        pass
-
-    # Fallback: follow redirect from releases/latest
-    response = client.get(GITHUB_HTML_RELEASES, follow_redirects=True)
-    if response.status_code == 200:
-        final_url = str(response.url)
-        if "/tag/" in final_url:
-            parts = final_url.split("/tag/")
-            if len(parts) > 1 and "/" not in parts[-1]:
-                return parts[-1]
-
-    raise RuntimeError("Failed to determine latest release tag from GitHub")
-
-
-def _load_cache_metadata(meta_file: Path) -> CacheMetadata | None:
-    if not meta_file.exists():
-        return None
-    try:
-        data = json.loads(meta_file.read_text())
-        return CacheMetadata.from_dict(data)
-    except (json.JSONDecodeError, ValueError):
-        return None
-
-
-def _save_cache_metadata(meta_file: Path, metadata: CacheMetadata) -> None:
-    meta_file.parent.mkdir(parents=True, exist_ok=True)
-    meta_file.write_text(json.dumps(metadata.to_dict(), indent=2))
-
-
-def get_codex_instructions(model: str = "gpt-5.1-codex", force_refresh: bool = False) -> str:
-    """Get Codex instructions for the given model.
-
-    Args:
-        model: Model name to get instructions for.
-        force_refresh: If True, bypass cache TTL and fetch fresh instructions.
-
-    Returns:
-        The Codex system prompt instructions.
-    """
-    model_family = get_model_family(model)
-    prompt_file = PROMPT_FILES[model_family]
-    cache_file = CACHE_DIR / CACHE_FILES[model_family]
-    meta_file = CACHE_DIR / f"{CACHE_FILES[model_family].replace('.md', '-meta.json')}"
-
-    # Check cache unless force refresh
-    if not force_refresh:
-        metadata = _load_cache_metadata(meta_file)
-        if metadata and cache_file.exists():
-            age = int(time.time()) - metadata.last_checked
-            if age < CACHE_TTL_SECONDS:
-                log_debug(f"Using cached {model_family} instructions (age: {age}s)", debug_type=DebugType.GENERAL)
-                return cache_file.read_text()
-
-    try:
-        with httpx.Client(timeout=30.0) as client:
-            latest_tag = _get_latest_release_tag(client)
-            instructions_url = f"{GITHUB_RAW_BASE}/{latest_tag}/codex-rs/core/{prompt_file}"
-
-            # Load existing metadata for conditional request
-            metadata = _load_cache_metadata(meta_file)
-            headers: dict[str, str] = {}
-
-            # Only use ETag if tag matches (different release = different content)
-            if metadata and metadata.tag == latest_tag and metadata.etag:
-                headers["If-None-Match"] = metadata.etag
-
-            response = client.get(instructions_url, headers=headers)
-
-            if response.status_code == 304 and cache_file.exists():
-                # Not modified, update last_checked and return cached
-                if metadata:
-                    metadata.last_checked = int(time.time())
-                    _save_cache_metadata(meta_file, metadata)
-                log_debug(f"Codex {model_family} instructions not modified", debug_type=DebugType.GENERAL)
-                return cache_file.read_text()
-
-            if response.status_code == 200:
-                instructions = response.text
-                new_etag = response.headers.get("etag")
-
-                # Save to cache
-                cache_file.parent.mkdir(parents=True, exist_ok=True)
-                cache_file.write_text(instructions)
-                _save_cache_metadata(
-                    meta_file,
-                    CacheMetadata(
-                        etag=new_etag,
-                        tag=latest_tag,
-                        last_checked=int(time.time()),
-                        url=instructions_url,
-                    ),
-                )
-
-                log_debug(f"Updated {model_family} instructions from GitHub", debug_type=DebugType.GENERAL)
-                return instructions
-
-            raise RuntimeError(f"HTTP {response.status_code}")
-
-    except Exception as e:
-        log_debug(f"Failed to fetch {model_family} instructions: {e}", debug_type=DebugType.GENERAL)
-
-        # Fallback to cached version
-        if cache_file.exists():
-            log_debug(f"Using cached {model_family} instructions (fallback)", debug_type=DebugType.GENERAL)
-            return cache_file.read_text()
-
-        # Last resort: use bundled prompt
-        bundled_path = _get_bundled_prompt_path(model_family)
-        if bundled_path:
-            log_debug(f"Using bundled {model_family} instructions (fallback)", debug_type=DebugType.GENERAL)
-            return _load_bundled_prompt(bundled_path)
-
-        raise RuntimeError(f"No Codex instructions available for {model_family}") from e
-
-
-def _get_bundled_prompt_path(model_family: ModelFamily) -> str | None:
-    """Get bundled prompt path for model family."""
-    if model_family == "gpt-5.2-codex":
-        return "prompts/prompt-codex-gpt-5-2-codex.md"
-    if model_family == "gpt-5.2":
-        return "prompts/prompt-codex-gpt-5-2.md"
-    if model_family in ("codex", "codex-max", "gpt-5.1"):
-        return "prompts/prompt-codex.md"
-    return None
-
-
-def invalidate_cache(model: str | None = None) -> None:
-    """Invalidate cached instructions to force refresh on next access.
-
-    Args:
-        model: If provided, only invalidate cache for this model's family.
-               If None, invalidate all cached instructions.
-    """
-    if model:
-        model_family = get_model_family(model)
-        meta_file = CACHE_DIR / f"{CACHE_FILES[model_family].replace('.md', '-meta.json')}"
-        if meta_file.exists():
-            meta_file.unlink()
-    else:
-        if CACHE_DIR.exists():
-            for meta_file in CACHE_DIR.glob("*-meta.json"):
-                meta_file.unlink()