klaude-code 1.2.23__tar.gz → 1.2.25__tar.gz

{klaude_code-1.2.23 → klaude_code-1.2.25}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.2.23
+Version: 1.2.25
 Summary: Add your description here
 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: markdown-it-py>=4.0.0
 Requires-Dist: openai>=1.102.0
 Requires-Dist: pillow>=12.0.0
 Requires-Dist: prompt-toolkit>=3.0.52

{klaude_code-1.2.23 → klaude_code-1.2.25}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "1.2.23"
+version = "1.2.25"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -13,6 +13,7 @@ dependencies = [
     "chardet>=5.2.0",
     "ddgs>=9.9.3",
     "diff-match-patch>=20241021",
+    "markdown-it-py>=4.0.0",
     "openai>=1.102.0",
     "pillow>=12.0.0",
     "prompt-toolkit>=3.0.52",

{klaude_code-1.2.23 → klaude_code-1.2.25}/src/klaude_code/cli/runtime.py

@@ -265,7 +265,23 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
         )
 
     # Set up input provider for interactive mode
-    input_provider: ui.InputProviderABC = ui.PromptToolkitInput(status_provider=_status_provider)
+    def _stop_rich_bottom_ui() -> None:
+        display = components.display
+        if isinstance(display, ui.REPLDisplay):
+            display.renderer.spinner_stop()
+            display.renderer.stop_bottom_live()
+        elif (
+            isinstance(display, ui.DebugEventDisplay)
+            and display.wrapped_display
+            and isinstance(display.wrapped_display, ui.REPLDisplay)
+        ):
+            display.wrapped_display.renderer.spinner_stop()
+            display.wrapped_display.renderer.stop_bottom_live()
+
+    input_provider: ui.InputProviderABC = ui.PromptToolkitInput(
+        status_provider=_status_provider,
+        pre_prompt=_stop_rich_bottom_ui,
+    )
 
     # --- Custom Ctrl+C handler: double-press within 2s to exit, single press shows toast ---
     def _show_toast_once() -> None:

klaude_code-1.2.25/src/klaude_code/command/prompt-jj-describe.md

@@ -0,0 +1,32 @@
+---
+description: Add description for current jj change
+---
+
+Run `jj status` and `jj diff --git` to see the current changes and add a description for the it.
+
+In order to ensure good formatting, ALWAYS pass the commit message via a HEREDOC, a la this example:<example>
+jj describe -m "$(cat <<'EOF'
+   Commit message here.
+   EOF
+   )"
+</example>
+
+Follow the [Conventional Commits](https://www.conventionalcommits.org/) specification:
+```
+<type>(<scope>): <description>
+```
+
+Types:
+- `feat`: New feature
+- `fix`: Bug fix
+- `docs`: Documentation changes
+- `style`: Code style changes (formatting, no logic change)
+- `refactor`: Code refactoring (no feature or fix)
+- `test`: Adding or updating tests
+- `chore`: Build process, dependencies, or tooling changes
+
+Examples:
+- `feat(cli): add --verbose flag for debug output`
+- `fix(llm): handle API timeout errors gracefully`
+- `docs(readme): update installation instructions`
+- `refactor(core): simplify session state management`

{klaude_code-1.2.23 → klaude_code-1.2.25}/src/klaude_code/command/thinking_cmd.py

@@ -56,6 +56,14 @@ def _is_gemini_flash_model(model_name: str | None) -> bool:
     return "gemini-3-flash" in model_name.lower()
 
 
+def should_auto_trigger_thinking(model_name: str | None) -> bool:
+    """Check if model should auto-trigger thinking selection on switch."""
+    if not model_name:
+        return False
+    model_lower = model_name.lower()
+    return "gpt-5" in model_lower or "gemini-3" in model_lower or "opus" in model_lower
+
+
 def _get_levels_for_responses(model_name: str | None) -> list[str]:
     """Get thinking levels for responses protocol."""
     if _is_codex_max_model(model_name):
@@ -69,7 +77,7 @@ def _get_levels_for_responses(model_name: str | None) -> list[str]:
     return RESPONSES_LEVELS
 
 
-def _format_current_thinking(config: llm_param.LLMConfigParameter) -> str:
+def format_current_thinking(config: llm_param.LLMConfigParameter) -> str:
     """Format the current thinking configuration for display."""
     thinking = config.thinking
     if not thinking:
@@ -164,6 +172,31 @@ def _select_anthropic_thinking_sync() -> llm_param.Thinking | None:
         return None
 
 
+async def select_thinking_for_protocol(config: llm_param.LLMConfigParameter) -> llm_param.Thinking | None:
+    """Select thinking configuration based on the LLM protocol.
+
+    Returns the selected Thinking config, or None if user cancelled.
+    """
+    protocol = config.protocol
+    model_name = config.model
+
+    if protocol in (llm_param.LLMClientProtocol.RESPONSES, llm_param.LLMClientProtocol.CODEX):
+        return await asyncio.to_thread(_select_responses_thinking_sync, model_name)
+
+    if protocol == llm_param.LLMClientProtocol.ANTHROPIC:
+        return await asyncio.to_thread(_select_anthropic_thinking_sync)
+
+    if protocol == llm_param.LLMClientProtocol.OPENROUTER:
+        if _is_openrouter_model_with_reasoning_effort(model_name):
+            return await asyncio.to_thread(_select_responses_thinking_sync, model_name)
+        return await asyncio.to_thread(_select_anthropic_thinking_sync)
+
+    if protocol == llm_param.LLMClientProtocol.OPENAI:
+        return await asyncio.to_thread(_select_anthropic_thinking_sync)
+
+    return None
+
+
 class ThinkingCommand(CommandABC):
     """Configure model thinking/reasoning level."""
 
@@ -185,40 +218,16 @@ class ThinkingCommand(CommandABC):
             return self._no_change_result(agent, "No profile configured")
 
         config = agent.profile.llm_client.get_llm_config()
-        protocol = config.protocol
-        model_name = config.model
-
-        current = _format_current_thinking(config)
-
-        # Select new thinking configuration based on protocol
-        new_thinking: llm_param.Thinking | None = None
-
-        if protocol in (llm_param.LLMClientProtocol.RESPONSES, llm_param.LLMClientProtocol.CODEX):
-            new_thinking = await asyncio.to_thread(_select_responses_thinking_sync, model_name)
-
-        elif protocol == llm_param.LLMClientProtocol.ANTHROPIC:
-            new_thinking = await asyncio.to_thread(_select_anthropic_thinking_sync)
-
-        elif protocol == llm_param.LLMClientProtocol.OPENROUTER:
-            if _is_openrouter_model_with_reasoning_effort(model_name):
-                new_thinking = await asyncio.to_thread(_select_responses_thinking_sync, model_name)
-            else:
-                new_thinking = await asyncio.to_thread(_select_anthropic_thinking_sync)
-
-        elif protocol == llm_param.LLMClientProtocol.OPENAI:
-            # openai_compatible uses anthropic style
-            new_thinking = await asyncio.to_thread(_select_anthropic_thinking_sync)
-
-        else:
-            return self._no_change_result(agent, f"Unsupported protocol: {protocol}")
+        current = format_current_thinking(config)
 
+        new_thinking = await select_thinking_for_protocol(config)
         if new_thinking is None:
             return self._no_change_result(agent, "(no change)")
 
         # Apply the new thinking configuration
         config.thinking = new_thinking
         agent.session.model_thinking = new_thinking
-        new_status = _format_current_thinking(config)
+        new_status = format_current_thinking(config)
 
         return CommandResult(
             events=[

klaude_code-1.2.23/src/klaude_code/const/__init__.py → klaude_code-1.2.25/src/klaude_code/const.py

@@ -93,7 +93,7 @@ TRUNCATE_DISPLAY_MAX_LINE_LENGTH = 1000
 TRUNCATE_DISPLAY_MAX_LINES = 8
 
 # Maximum lines for sub-agent result display
-SUB_AGENT_RESULT_MAX_LINES = 20
+SUB_AGENT_RESULT_MAX_LINES = 50
 
 
 # UI refresh rate (frames per second) for debounced content streaming
@@ -111,19 +111,20 @@ MARKDOWN_RIGHT_MARGIN = 2
 # Status hint text shown after spinner status
 STATUS_HINT_TEXT = " (esc to interrupt)"
 
+# Default spinner status text when idle/thinking
+STATUS_DEFAULT_TEXT = "Thinking …"
+
 # Status shimmer animation
 # Horizontal padding used when computing shimmer band position
 STATUS_SHIMMER_PADDING = 10
-# Duration in seconds for one full shimmer sweep across the text
-STATUS_SHIMMER_SWEEP_SECONDS = 2
 # Half-width of the shimmer band in characters
 STATUS_SHIMMER_BAND_HALF_WIDTH = 5.0
 # Scale factor applied to shimmer intensity when blending colors
 STATUS_SHIMMER_ALPHA_SCALE = 0.7
 
-# Spinner breathing animation
-# Duration in seconds for one full breathe-in + breathe-out cycle
-# Keep in sync with STATUS_SHIMMER_SWEEP_SECONDS for visual consistency
+# Spinner breathing and shimmer animation period
+# Duration in seconds for one full breathe-in + breathe-out cycle (breathing)
+# and one full shimmer sweep across the text (shimmer)
 SPINNER_BREATH_PERIOD_SECONDS: float = 2.0
 
 

{klaude_code-1.2.23 → klaude_code-1.2.25}/src/klaude_code/core/executor.py

@@ -14,6 +14,11 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from klaude_code.command import dispatch_command
+from klaude_code.command.thinking_cmd import (
+    format_current_thinking,
+    select_thinking_for_protocol,
+    should_auto_trigger_thinking,
+)
 from klaude_code.config import load_config
 from klaude_code.core.agent import Agent, DefaultModelProfileProvider, ModelProfileProvider
 from klaude_code.core.manager import LLMClients, SubAgentManager
@@ -235,17 +240,55 @@ class ExecutorContext:
         agent.session.model_thinking = llm_config.thinking
 
         developer_item = model.DeveloperMessageItem(
-            content=f"switched to model: {operation.model_name}",
+            content=f"Switched to: {llm_config.model}",
             command_output=model.CommandOutput(command_name=commands.CommandName.MODEL),
         )
         agent.session.append_history([developer_item])
 
         await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
-        await self.emit_event(events.WelcomeEvent(llm_config=llm_config, work_dir=str(agent.session.work_dir)))
 
         if self._on_model_change is not None:
             self._on_model_change(llm_client.model_name)
 
+        if should_auto_trigger_thinking(llm_config.model):
+            thinking_op = op.ChangeThinkingOperation(session_id=operation.session_id)
+            await thinking_op.execute(handler=self)
+            # WelcomeEvent is already handled by the thinking change
+        else:
+            await self.emit_event(events.WelcomeEvent(llm_config=llm_config, work_dir=str(agent.session.work_dir)))
+
+    async def handle_change_thinking(self, operation: op.ChangeThinkingOperation) -> None:
+        """Handle a change thinking operation by prompting user to select thinking level."""
+        agent = await self._ensure_agent(operation.session_id)
+        if not agent.profile:
+            return
+
+        config = agent.profile.llm_client.get_llm_config()
+        current = format_current_thinking(config)
+
+        new_thinking = await select_thinking_for_protocol(config)
+
+        if new_thinking is None:
+            developer_item = model.DeveloperMessageItem(
+                content="(thinking unchanged)",
+                command_output=model.CommandOutput(command_name=commands.CommandName.THINKING),
+            )
+            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+            return
+
+        config.thinking = new_thinking
+        agent.session.model_thinking = new_thinking
+        new_status = format_current_thinking(config)
+
+        developer_item = model.DeveloperMessageItem(
+            content=f"Thinking changed: {current} -> {new_status}",
+            command_output=model.CommandOutput(command_name=commands.CommandName.THINKING),
+        )
+        agent.session.append_history([developer_item])
+
+        await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+        await self.emit_event(events.WelcomeEvent(work_dir=str(agent.session.work_dir), llm_config=config))
+
     async def handle_clear_session(self, operation: op.ClearSessionOperation) -> None:
         agent = await self._ensure_agent(operation.session_id)
         new_session = Session.create(work_dir=agent.session.work_dir)
@@ -327,7 +370,7 @@ class ExecutorContext:
             log_debug(traceback.format_exc(), style="red", debug_type=DebugType.EXECUTION)
             await self.emit_event(
                 events.ErrorEvent(
-                    error_message=f"Agent task failed: [{e.__class__.__name__}] {e!s}",
+                    error_message=f"Agent task failed: [{e.__class__.__name__}] {e!s} {traceback.format_exc()}",
                     can_retry=False,
                 )
             )

{klaude_code-1.2.23 → klaude_code-1.2.25}/src/klaude_code/core/tool/file/read_tool.py

@@ -25,6 +25,18 @@ _IMAGE_MIME_TYPES: dict[str, str] = {
     ".webp": "image/webp",
 }
 
+_BINARY_CHECK_SIZE = 8192
+
+
+def _is_binary_file(file_path: str) -> bool:
+    """Check if a file is binary by looking for null bytes in the first chunk."""
+    try:
+        with open(file_path, "rb") as f:
+            chunk = f.read(_BINARY_CHECK_SIZE)
+            return b"\x00" in chunk
+    except OSError:
+        return False
+
 
 def _format_numbered_line(line_no: int, content: str) -> str:
     # 6-width right-aligned line number followed by a right arrow
@@ -218,12 +230,22 @@ class ReadTool(ToolABC):
                 ),
             )
 
+        is_image_file = _is_supported_image_file(file_path)
+        # Check for binary files (skip for images which are handled separately)
+        if not is_image_file and _is_binary_file(file_path):
+            return model.ToolResultItem(
+                status="error",
+                output=(
+                    "<tool_use_error>This appears to be a binary file and cannot be read as text. "
+                    "Use appropriate tools or libraries to handle binary files.</tool_use_error>"
+                ),
+            )
+
         try:
             size_bytes = Path(file_path).stat().st_size
         except OSError:
             size_bytes = 0
 
-        is_image_file = _is_supported_image_file(file_path)
         if is_image_file:
             if size_bytes > const.READ_MAX_IMAGE_BYTES:
                 size_mb = size_bytes / (1024 * 1024)

{klaude_code-1.2.23 → klaude_code-1.2.25}/src/klaude_code/core/tool/file/write_tool.py

@@ -124,9 +124,13 @@ class WriteTool(ToolABC):
                     is_memory=is_mem,
                 )
 
-        # Build diff between previous and new content
-        after = args.content
-        ui_extra = build_structured_diff(before, after, file_path=file_path)
+        # For markdown files, use MarkdownDocUIExtra to render content as markdown
+        # Otherwise, build diff between previous and new content
+        ui_extra: model.ToolResultUIExtra | None
+        if file_path.endswith(".md"):
+            ui_extra = model.MarkdownDocUIExtra(file_path=file_path, content=args.content)
+        else:
+            ui_extra = build_structured_diff(before, args.content, file_path=file_path)
 
         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-1.2.25/src/klaude_code/llm/openai_compatible/client.py

@@ -0,0 +1,119 @@
+import json
+from collections.abc import AsyncGenerator
+from typing import Any, override
+
+import httpx
+import openai
+from openai.types.chat.completion_create_params import CompletionCreateParamsStreaming
+
+from klaude_code.llm.client import LLMClientABC
+from klaude_code.llm.input_common import apply_config_defaults
+from klaude_code.llm.openai_compatible.input import convert_history_to_input, convert_tool_schema
+from klaude_code.llm.openai_compatible.stream import DefaultReasoningHandler, parse_chat_completions_stream
+from klaude_code.llm.registry import register
+from klaude_code.llm.usage import MetadataTracker
+from klaude_code.protocol import llm_param, model
+from klaude_code.trace import DebugType, log_debug
+
+
+def build_payload(param: llm_param.LLMCallParameter) -> tuple[CompletionCreateParamsStreaming, dict[str, object]]:
+    """Build OpenAI API request parameters."""
+    messages = convert_history_to_input(param.input, param.system, param.model)
+    tools = convert_tool_schema(param.tools)
+
+    extra_body: dict[str, object] = {}
+
+    if param.thinking and param.thinking.type == "enabled":
+        extra_body["thinking"] = {
+            "type": param.thinking.type,
+            "budget": param.thinking.budget_tokens,
+        }
+
+    payload: CompletionCreateParamsStreaming = {
+        "model": str(param.model),
+        "tool_choice": "auto",
+        "parallel_tool_calls": True,
+        "stream": True,
+        "messages": messages,
+        "temperature": param.temperature,
+        "max_tokens": param.max_tokens,
+        "tools": tools,
+        "reasoning_effort": param.thinking.reasoning_effort if param.thinking else None,
+        "verbosity": param.verbosity,
+    }
+
+    return payload, extra_body
+
+
+@register(llm_param.LLMClientProtocol.OPENAI)
+class OpenAICompatibleClient(LLMClientABC):
+    def __init__(self, config: llm_param.LLMConfigParameter):
+        super().__init__(config)
+        if config.is_azure:
+            if not config.base_url:
+                raise ValueError("Azure endpoint is required")
+            client = openai.AsyncAzureOpenAI(
+                api_key=config.api_key,
+                azure_endpoint=str(config.base_url),
+                api_version=config.azure_api_version,
+                timeout=httpx.Timeout(300.0, connect=15.0, read=285.0),
+            )
+        else:
+            client = openai.AsyncOpenAI(
+                api_key=config.api_key,
+                base_url=config.base_url,
+                timeout=httpx.Timeout(300.0, connect=15.0, read=285.0),
+            )
+        self.client: openai.AsyncAzureOpenAI | openai.AsyncOpenAI = client
+
+    @classmethod
+    @override
+    def create(cls, config: llm_param.LLMConfigParameter) -> "LLMClientABC":
+        return cls(config)
+
+    @override
+    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem]:
+        param = apply_config_defaults(param, self.get_llm_config())
+
+        metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
+
+        payload, extra_body = build_payload(param)
+        extra_headers: dict[str, str] = {"extra": json.dumps({"session_id": param.session_id}, sort_keys=True)}
+
+        log_debug(
+            json.dumps({**payload, **extra_body}, ensure_ascii=False, default=str),
+            style="yellow",
+            debug_type=DebugType.LLM_PAYLOAD,
+        )
+
+        try:
+            stream = await self.client.chat.completions.create(
+                **payload,
+                extra_body=extra_body,
+                extra_headers=extra_headers,
+            )
+        except (openai.OpenAIError, httpx.HTTPError) as e:
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
+            yield metadata_tracker.finalize()
+            return
+
+        reasoning_handler = DefaultReasoningHandler(
+            param_model=str(param.model),
+            response_id=None,
+        )
+
+        def on_event(event: Any) -> None:
+            log_debug(
+                event.model_dump_json(exclude_none=True),
+                style="blue",
+                debug_type=DebugType.LLM_STREAM,
+            )
+
+        async for item in parse_chat_completions_stream(
+            stream,
+            param=param,
+            metadata_tracker=metadata_tracker,
+            reasoning_handler=reasoning_handler,
+            on_event=on_event,
+        ):
+            yield item