klaude-code 2.26.0__tar.gz → 2.27.0__tar.gz

{klaude_code-2.26.0 → klaude_code-2.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.26.0
+Version: 2.27.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic[bedrock]>=0.66.0
 Requires-Dist: chardet>=5.2.0,<6

{klaude_code-2.26.0 → klaude_code-2.27.0}/pyproject.toml

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

{klaude_code-2.26.0 → klaude_code-2.27.0}/src/klaude_code/agent/prompt_suggestion/prompt_suggestion.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 
 import asyncio
 import re
+from dataclasses import dataclass
 
 from klaude_code.agent.agent_profile import AgentProfile
 from klaude_code.agent.cache_safe import CacheSafeParams, build_cache_safe_messages
@@ -22,7 +23,9 @@ from klaude_code.prompts.prompt_suggestion import PROMPT_SUGGESTION_PROMPT
 from klaude_code.protocol import llm_param, message
 from klaude_code.session.session import Session
 
-_MAX_SUGGESTION_TOKENS = 128
+# Reasoning models (for example gpt-5.4) may spend most of a tiny budget on
+# thinking, leaving no visible suggestion text in the final output.
+_MAX_SUGGESTION_TOKENS = 4096
 _MIN_ASSISTANT_TURNS = 2
 
 # Cache cold heuristic: if the parent response's own output + uncached input
@@ -31,6 +34,13 @@ _MIN_ASSISTANT_TURNS = 2
 _MAX_PARENT_UNCACHED_TOKENS = 10_000
 
 
+@dataclass(frozen=True)
+class PromptSuggestionResult:
+    suggestion: str | None
+    raw: str
+    drop_reason: str | None = None
+
+
 def should_suggest(session: Session) -> str | None:
     """Return a suppression reason or ``None`` when generation is allowed.
 
@@ -79,9 +89,11 @@ async def run_prompt_suggestion(
     session: Session,
     main_profile: AgentProfile,
     cancel: asyncio.Event | None = None,
-) -> str | None:
-    """Ask the main LLM to predict the user's next prompt. Returns the text,
-    or ``None`` when the model replied ``[DONE]`` / the output was filtered.
+) -> PromptSuggestionResult | None:
+    """Ask the main LLM to predict the user's next prompt.
+
+    Returns a result object after a successful model call, or ``None`` when the
+    call/stream failed before a usable response was produced.
 
     The wire prefix equals ``session.get_llm_history()`` (parent's most recent
     request), and the appended UserMessage is the suggestion instruction.
@@ -143,16 +155,20 @@ async def run_prompt_suggestion(
             f"input={usage.input_tokens} output={usage.output_tokens}",
             debug_type=DebugType.RESPONSE,
         )
-    suggestion = _normalize(raw)
-    if suggestion is None:
+    result = _finalize_result(raw)
+    if result.suggestion is None and result.drop_reason == "done_or_empty":
         log_debug("[PromptSuggestion] filtered ([DONE] or empty)", raw, debug_type=DebugType.RESPONSE)
-        return None
-    reason = _filter_reason(suggestion)
-    if reason is not None:
-        log_debug(f"[PromptSuggestion] filtered ({reason})", suggestion, debug_type=DebugType.RESPONSE)
-        return None
-    log_debug("[PromptSuggestion] accepted", suggestion, debug_type=DebugType.RESPONSE)
-    return suggestion
+        return result
+    if result.drop_reason is not None:
+        log_debug(
+            f"[PromptSuggestion] filtered ({result.drop_reason})",
+            result.suggestion or result.raw,
+            debug_type=DebugType.RESPONSE,
+        )
+        return result
+    assert result.suggestion is not None
+    log_debug("[PromptSuggestion] accepted", result.suggestion, debug_type=DebugType.RESPONSE)
+    return result
 
 
 _DONE_RE = re.compile(r"^\s*\[\s*done\s*\]\s*$", re.IGNORECASE)
@@ -196,3 +212,15 @@ def _filter_reason(suggestion: str) -> str | None:
     if _ASSISTANT_VOICE_RE.match(suggestion):
         return "assistant_voice"
     return None
+
+
+def _finalize_result(raw: str) -> PromptSuggestionResult:
+    suggestion = _normalize(raw)
+    if suggestion is None:
+        return PromptSuggestionResult(suggestion=None, raw=raw, drop_reason="done_or_empty")
+
+    reason = _filter_reason(suggestion)
+    if reason is not None:
+        return PromptSuggestionResult(suggestion=None, raw=raw, drop_reason=reason)
+
+    return PromptSuggestionResult(suggestion=suggestion, raw=raw)

{klaude_code-2.26.0 → klaude_code-2.27.0}/src/klaude_code/agent/runtime/agent_ops.py

@@ -458,7 +458,7 @@ class AgentOperationHandler:
     async def _generate_prompt_suggestion(self, agent: Agent) -> None:
         session = agent.session
         try:
-            suggestion = await run_prompt_suggestion(
+            result = await run_prompt_suggestion(
                 session=session,
                 main_profile=agent.profile,
             )
@@ -474,12 +474,19 @@ class AgentOperationHandler:
                 debug_type=DebugType.EXECUTION,
             )
             return
-        if suggestion is None:
+        if result is None:
             log_debug(
-                f"[PromptSuggestion] no suggestion session={session.id} (model returned [DONE] or filtered)",
+                f"[PromptSuggestion] no suggestion session={session.id} (generation failed before a response was produced)",
                 debug_type=DebugType.EXECUTION,
             )
             return
+        if result.suggestion is None:
+            log_debug(
+                f"[PromptSuggestion] no suggestion session={session.id} reason={result.drop_reason} raw={result.raw!r}",
+                debug_type=DebugType.EXECUTION,
+            )
+            return
+        suggestion = result.suggestion
         log_debug(
             f"[PromptSuggestion] ready session={session.id}",
             suggestion,

{klaude_code-2.26.0 → klaude_code-2.27.0}/src/klaude_code/agent/session_title.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import re
 
 from klaude_code.llm.client import LLMClientABC
@@ -14,6 +15,7 @@ _SESSION_TITLE_SYSTEM_PROMPT = (
     "Reply with only the title, no quotes, no markdown, no explanation."
 )
 
+_SESSION_TITLE_MAX_ATTEMPTS = 3
 _SESSION_TITLE_MAX_TOKENS = 4096
 
 
@@ -78,21 +80,40 @@ async def generate_session_title(
         debug_type=DebugType.RESPONSE,
     )
 
-    stream = await llm_client.call(call_param)
-    parts: list[str] = []
-    final_text: str | None = None
-    stop_reason: str | None = None
-    async for item in stream:
-        if isinstance(item, message.AssistantTextDelta):
-            parts.append(item.content)
-        elif isinstance(item, message.AssistantMessage):
-            final_text = message.join_text_parts(item.parts)
-            stop_reason = item.stop_reason
-        elif isinstance(item, message.StreamErrorItem):
-            raise RuntimeError(item.error)
+    for attempt in range(1, _SESSION_TITLE_MAX_ATTEMPTS + 1):
+        try:
+            stream = await llm_client.call(call_param)
+            parts: list[str] = []
+            final_text: str | None = None
+            stop_reason: str | None = None
+            async for item in stream:
+                if isinstance(item, message.AssistantTextDelta):
+                    parts.append(item.content)
+                elif isinstance(item, message.AssistantMessage):
+                    final_text = message.join_text_parts(item.parts)
+                    stop_reason = item.stop_reason
+                elif isinstance(item, message.StreamErrorItem):
+                    raise RuntimeError(item.error)
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            if attempt == _SESSION_TITLE_MAX_ATTEMPTS:
+                raise
+            log_debug(
+                f"[SessionTitle] attempt {attempt}/{_SESSION_TITLE_MAX_ATTEMPTS} failed: {exc!s}; retrying",
+                debug_type=DebugType.RESPONSE,
+            )
+            continue
 
-    title = _normalize_session_title(final_text if final_text is not None else "".join(parts))
-    if stop_reason:
-        log_debug(f"[SessionTitle] stop_reason {stop_reason}", debug_type=DebugType.RESPONSE)
-    log_debug("[SessionTitle] result", title or "<empty>", debug_type=DebugType.RESPONSE)
-    return title
+        title = _normalize_session_title(final_text if final_text is not None else "".join(parts))
+        if stop_reason:
+            log_debug(f"[SessionTitle] stop_reason {stop_reason}", debug_type=DebugType.RESPONSE)
+        if title is not None or attempt == _SESSION_TITLE_MAX_ATTEMPTS:
+            log_debug("[SessionTitle] result", title or "<empty>", debug_type=DebugType.RESPONSE)
+            return title
+        log_debug(
+            f"[SessionTitle] attempt {attempt}/{_SESSION_TITLE_MAX_ATTEMPTS} returned empty title; retrying",
+            debug_type=DebugType.RESPONSE,
+        )
+
+    return None

{klaude_code-2.26.0 → klaude_code-2.27.0}/src/klaude_code/const.py

@@ -45,6 +45,11 @@ LLM_HTTP_TIMEOUT_READ = 285.0  # HTTP read timeout (seconds)
 ANTHROPIC_BETA_INTERLEAVED_THINKING = "interleaved-thinking-2025-05-14"  # Anthropic API beta flag
 ANTHROPIC_BETA_CONTEXT_MANAGEMENT = "context-management-2025-06-27"  # Anthropic API beta flag for context editing
 
+# Bedrock transport selector (internal). True uses native ConverseStream via boto3;
+# False routes through `anthropic.AsyncAnthropicBedrock` and reuses the Anthropic
+# messages streaming path.
+BEDROCK_USE_CONVERSE_STREAM = False
+
 OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"  # OpenRouter API base URL
 
 CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex"  # Codex API base URL

{klaude_code-2.26.0 → klaude_code-2.27.0}/src/klaude_code/llm/bedrock_anthropic/client.py

@@ -23,13 +23,15 @@ import httpx
 from klaude_code.const import (
     ANTHROPIC_BETA_CONTEXT_MANAGEMENT,
     ANTHROPIC_BETA_INTERLEAVED_THINKING,
+    BEDROCK_USE_CONVERSE_STREAM,
     DEFAULT_ANTHROPIC_THINKING_BUDGET_TOKENS,
     DEFAULT_MAX_TOKENS,
     DEFAULT_TEMPERATURE,
     LLM_HTTP_TIMEOUT_CONNECT,
     LLM_HTTP_TIMEOUT_READ,
+    LLM_HTTP_TIMEOUT_TOTAL,
 )
-from klaude_code.llm.anthropic.client import AnthropicStreamStateManager
+from klaude_code.llm.anthropic.client import AnthropicLLMStream, AnthropicStreamStateManager, build_payload
 from klaude_code.llm.anthropic.input import convert_history_to_input, convert_system_to_input
 from klaude_code.llm.client import LLMClientABC, LLMStreamABC
 from klaude_code.llm.image import detect_mime_type_from_bytes, parse_data_url
@@ -154,7 +156,11 @@ def _convert_content_block(block: dict[str, Any], *, model_id: str) -> list[dict
     result: list[dict[str, Any]] = []
 
     if block_type == "text":
-        result.append({"text": block.get("text", "")})
+        text = cast(str, block.get("text") or "")
+        # Bedrock ConverseStream rejects blank text blocks; drop them and
+        # keep the cache boundary only if cache_control was set.
+        if text:
+            result.append({"text": text})
         _append_cache_point(result, block)
         return result
 
@@ -168,6 +174,9 @@ def _convert_content_block(block: dict[str, Any], *, model_id: str) -> list[dict
         tool_content: list[dict[str, Any]] = []
         for item in cast(list[dict[str, Any]], block.get("content", [])):
             tool_content.extend(_convert_content_block(item, model_id=model_id))
+        if not tool_content:
+            # toolResult.content cannot be empty on Bedrock ConverseStream.
+            tool_content = [{"text": " "}]
         result.append(
             {
                 "toolResult": {
@@ -238,7 +247,9 @@ def _convert_messages(param: llm_param.LLMCallParameter) -> list[dict[str, Any]]
         for block in cast(list[dict[str, Any]], msg.get("content", [])):
             content.extend(_convert_content_block(block, model_id=model_id))
         if not content:
-            content = [{"text": ""}]
+            # Bedrock ConverseStream rejects empty or blank-text content; use a
+            # single space as a minimal placeholder to keep turn structure intact.
+            content = [{"text": " "}]
         result.append({"role": msg["role"], "content": content})
 
     return result
@@ -253,7 +264,9 @@ def _convert_system(param: llm_param.LLMCallParameter) -> list[dict[str, Any]]:
     result.append({"cachePoint": {"type": "default"}})
 
     for block in system_blocks:
-        result.append({"text": block["text"]})
+        text = cast(str, block.get("text") or "")
+        if text:
+            result.append({"text": text})
         if block.get("cache_control"):
             result.append({"cachePoint": {"type": "default"}})
 
@@ -544,10 +557,24 @@ class BedrockLLMStream(LLMStreamABC):
 
 @register(llm_param.LLMClientProtocol.BEDROCK)
 class BedrockClient(LLMClientABC):
-    """LLM client for AWS Bedrock using native ConverseStream."""
+    """LLM client for AWS Bedrock.
+
+    Defaults to native ConverseStream via boto3. When `BEDROCK_USE_CONVERSE_STREAM`
+    is False, routes through `anthropic.AsyncAnthropicBedrock` and reuses the
+    Anthropic messages streaming parser.
+    """
 
     def __init__(self, config: llm_param.LLMConfigParameter):
         super().__init__(config)
+
+        if BEDROCK_USE_CONVERSE_STREAM:
+            self._messages_client: Any = None
+            self._init_converse_client(config)
+        else:
+            self.client: Any = None
+            self._init_messages_client(config)
+
+    def _init_converse_client(self, config: llm_param.LLMConfigParameter) -> None:
         missing = [name for name in ("boto3", "botocore") if find_spec(name) is None]
         if missing:
             missing_names = ", ".join(missing)
@@ -572,7 +599,7 @@ class BedrockClient(LLMClientABC):
             session_kwargs["profile_name"] = config.aws_profile
 
         session: Any = boto3.Session(**session_kwargs)
-        self.client: Any = session.client(
+        self.client = session.client(
             "bedrock-runtime",
             region_name=config.aws_region,
             config=Config(
@@ -582,6 +609,18 @@ class BedrockClient(LLMClientABC):
         )
         self.client.meta.events.register("before-sign.bedrock-runtime", _inject_session_id_header)
 
+    def _init_messages_client(self, config: llm_param.LLMConfigParameter) -> None:
+        import anthropic
+
+        self._messages_client = anthropic.AsyncAnthropicBedrock(
+            aws_access_key=config.aws_access_key,
+            aws_secret_key=config.aws_secret_key,
+            aws_session_token=config.aws_session_token,
+            aws_region=config.aws_region,
+            aws_profile=config.aws_profile,
+            timeout=httpx.Timeout(LLM_HTTP_TIMEOUT_TOTAL, connect=LLM_HTTP_TIMEOUT_CONNECT, read=LLM_HTTP_TIMEOUT_READ),
+        )
+
     @classmethod
     @override
     def create(cls, config: llm_param.LLMConfigParameter) -> "LLMClientABC":
@@ -590,8 +629,11 @@ class BedrockClient(LLMClientABC):
     @override
     async def call(self, param: llm_param.LLMCallParameter) -> LLMStreamABC:
         param = apply_config_defaults(param, self.get_llm_config())
-
         metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
+
+        if not BEDROCK_USE_CONVERSE_STREAM:
+            return await self._call_messages(param, metadata_tracker)
+
         request = await asyncio.to_thread(build_bedrock_request, param, region=self.get_llm_config().aws_region)
 
         log_debug(
@@ -612,3 +654,30 @@ class BedrockClient(LLMClientABC):
         ) as e:
             error_message = f"{e.__class__.__name__} {e!s}"
             return error_llm_stream(metadata_tracker, error=error_message)
+
+    async def _call_messages(
+        self,
+        param: llm_param.LLMCallParameter,
+        metadata_tracker: MetadataTracker,
+    ) -> LLMStreamABC:
+        import anthropic
+
+        payload = build_payload(param)
+        log_debug(
+            json.dumps(payload, ensure_ascii=False, default=str),
+            debug_type=DebugType.LLM_PAYLOAD,
+        )
+
+        extra_headers: dict[str, str] = {}
+        if param.session_id:
+            extra_headers["x-session-id"] = param.session_id
+
+        try:
+            stream = self._messages_client.beta.messages.create(
+                **payload,
+                extra_headers=extra_headers,
+            )
+            return AnthropicLLMStream(stream, param=param, metadata_tracker=metadata_tracker)
+        except (anthropic.APIError, httpx.HTTPError) as e:
+            error_message = f"{e.__class__.__name__} {e!s}"
+            return error_llm_stream(metadata_tracker, error=error_message)

{klaude_code-2.26.0 → klaude_code-2.27.0}/src/klaude_code/tui/machine.py

@@ -94,6 +94,10 @@ def _empty_bash_chunks() -> list[str]:
     return []
 
 
+def _is_cancelled_task_result(task_result: str) -> bool:
+    return task_result.strip().lower() in {"task cancelled", "task canceled"}
+
+
 @dataclass
 class _PendingBashToolOutput:
     started_at: float
@@ -828,7 +832,7 @@ class DisplayStateMachine:
                         self._primary_session_id = e.session_id
                     if not is_replay:
                         cmds.append(TaskClockStart())
-                        self._terminal_title_prefix = "\u26ac"
+                        self._terminal_title_prefix = "⠋"
                         cmds.append(
                             StartTitleBlink(
                                 model_name=self._model_name,
@@ -1282,7 +1286,7 @@ class DisplayStateMachine:
                     and not s.is_sub_agent
                     and s.assistant_char_count == 0
                     and e.task_result.strip()
-                    and e.task_result.strip().lower() not in {"task cancelled", "task canceled"}
+                    and not _is_cancelled_task_result(e.task_result)
                 ):
                     cmds.append(StartAssistantStream(session_id=e.session_id))
                     cmds.append(AppendAssistant(session_id=e.session_id, content=e.task_result))
@@ -1293,7 +1297,7 @@ class DisplayStateMachine:
                     self._spinner.clear_task_state()
                     cmds.append(SpinnerStop())
                     cmds.append(StopTitleBlink())
-                    self._terminal_title_prefix = "\u2714"
+                    self._terminal_title_prefix = None if _is_cancelled_task_result(e.task_result) else "✅"
                     cmds.append(
                         UpdateTerminalTitlePrefix(
                             prefix=self._terminal_title_prefix,

{klaude_code-2.26.0 → klaude_code-2.27.0}/src/klaude_code/tui/renderer.py

@@ -955,9 +955,10 @@ class TUICommandRenderer:
         if self.is_sub_agent_session(event.event.session_id):
             return
         body = self._compact_result_text(event.event.task_result)
+        normalized_result = event.event.task_result.strip().lower()
         notification = Notification(
             type=NotificationType.AGENT_TASK_COMPLETE,
-            title="Task Completed",
+            title="Task Cancelled" if normalized_result in {"task cancelled", "task canceled"} else "Task Completed",
             body=body,
         )
         self._notifier.notify(notification)

{klaude_code-2.26.0 → klaude_code-2.27.0}/src/klaude_code/tui/terminal/title.py

@@ -7,9 +7,9 @@ import sys
 
 from klaude_code.log import DebugType, log_debug
 
-# Blink state: alternates terminal title prefix between small squares
-_BLINK_GLYPHS = ("\u25ab", "\u25aa")  # ▫ ▪
-_BLINK_INTERVAL = 0.8  # seconds
+# Blink state: cycles a single-glyph Braille spinner to keep title width stable.
+_BLINK_PREFIXES = ("⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏")
+_BLINK_INTERVAL = 0.08  # seconds
 
 _blink_task: asyncio.Task[None] | None = None
 _blink_model_name: str | None = None
@@ -25,6 +25,19 @@ def _format_session_title(session_title: str | None) -> str | None:
     return single_line[:80]
 
 
+def _project_name(work_dir: str | None) -> str:
+    folder_name = os.path.basename(work_dir or os.getcwd())
+    return folder_name or "klaude"
+
+
+def _build_terminal_title(work_dir: str | None, session_title: str | None) -> str:
+    project_name = _project_name(work_dir)
+    formatted_session_title = _format_session_title(session_title)
+    if formatted_session_title:
+        return f"{project_name} · {formatted_session_title}"
+    return f"{project_name} · klaude"
+
+
 def set_terminal_title(title: str) -> None:
     """Set terminal window title using an ANSI escape sequence."""
     stream = getattr(sys, "__stdout__", None) or sys.stdout
@@ -49,21 +62,8 @@ def update_terminal_title(
     work_dir: str | None = None,
     session_title: str | None = None,
 ) -> None:
-    """Update terminal title with folder name, optional model name, and session title."""
-    formatted_session_title = _format_session_title(session_title)
-    if formatted_session_title:
-        title = formatted_session_title
-        if prefix:
-            title = f"{prefix} {title}"
-        set_terminal_title(title)
-        return
-
-    folder_name = os.path.basename(work_dir or os.getcwd())
-    if model_name:
-        model_alias = model_name.split("@")[0]
-        title = f"klaude [{model_alias}] · {folder_name}"
-    else:
-        title = f"klaude · {folder_name}"
+    """Update terminal title with an optional status prefix and session title."""
+    title = _build_terminal_title(work_dir, session_title)
 
     if prefix:
         title = f"{prefix} {title}"
@@ -72,7 +72,7 @@ def update_terminal_title(
 
 
 # ---------------------------------------------------------------------------
-# Terminal title blink (hollow/solid circle alternation while task is active)
+# Terminal title blink (single-glyph spinner while task is active)
 # ---------------------------------------------------------------------------
 
 
@@ -81,15 +81,15 @@ async def _blink_loop() -> None:
     while True:
         update_terminal_title(
             _blink_model_name,
-            prefix=_BLINK_GLYPHS[idx],
+            prefix=_BLINK_PREFIXES[idx],
             session_title=_blink_session_title,
         )
-        idx = 1 - idx
+        idx = (idx + 1) % len(_BLINK_PREFIXES)
         await asyncio.sleep(_BLINK_INTERVAL)
 
 
 def start_terminal_title_blink(model_name: str | None, session_title: str | None) -> None:
-    """Start alternating the terminal title prefix between hollow and solid circle."""
+    """Start cycling the terminal title prefix through the active-task spinner."""
     global _blink_task, _blink_model_name, _blink_session_title
     stop_terminal_title_blink()
     _blink_model_name = model_name