klaude-code 1.5.0__py3-none-any.whl → 1.7.0__py3-none-any.whl

klaude_code/llm/google/input.py

@@ -0,0 +1,215 @@
+# pyright: reportReturnType=false
+# pyright: reportArgumentType=false
+# pyright: reportUnknownMemberType=false
+# pyright: reportAttributeAccessIssue=false
+
+import json
+from base64 import b64decode
+from binascii import Error as BinasciiError
+from typing import Any
+
+from google.genai import types
+
+from klaude_code.llm.input_common import AssistantGroup, ToolGroup, UserGroup, merge_reminder_text, parse_message_groups
+from klaude_code.protocol import llm_param, model
+
+
+def _data_url_to_blob(url: str) -> types.Blob:
+    header_and_media = url.split(",", 1)
+    if len(header_and_media) != 2:
+        raise ValueError("Invalid data URL for image: missing comma separator")
+    header, base64_data = header_and_media
+    if not header.startswith("data:"):
+        raise ValueError("Invalid data URL for image: missing data: prefix")
+    if ";base64" not in header:
+        raise ValueError("Invalid data URL for image: missing base64 marker")
+
+    media_type = header[5:].split(";", 1)[0]
+    base64_payload = base64_data.strip()
+    if base64_payload == "":
+        raise ValueError("Inline image data is empty")
+
+    try:
+        decoded = b64decode(base64_payload, validate=True)
+    except (BinasciiError, ValueError) as exc:
+        raise ValueError("Inline image data is not valid base64") from exc
+
+    return types.Blob(data=decoded, mime_type=media_type)
+
+
+def _image_part_to_part(image: model.ImageURLPart) -> types.Part:
+    url = image.image_url.url
+    if url.startswith("data:"):
+        return types.Part(inline_data=_data_url_to_blob(url))
+    # Best-effort: Gemini supports file URIs, and may accept public HTTPS URLs.
+    return types.Part(file_data=types.FileData(file_uri=url))
+
+
+def _user_group_to_content(group: UserGroup) -> types.Content:
+    parts: list[types.Part] = []
+    for text in group.text_parts:
+        parts.append(types.Part(text=text + "\n"))
+    for image in group.images:
+        parts.append(_image_part_to_part(image))
+    if not parts:
+        parts.append(types.Part(text=""))
+    return types.Content(role="user", parts=parts)
+
+
+def _tool_groups_to_content(groups: list[ToolGroup], model_name: str | None) -> list[types.Content]:
+    supports_multimodal_function_response = bool(model_name and "gemini-3" in model_name.lower())
+
+    response_parts: list[types.Part] = []
+    extra_image_contents: list[types.Content] = []
+
+    for group in groups:
+        merged_text = merge_reminder_text(
+            group.tool_result.output or "<system-reminder>Tool ran without output or errors</system-reminder>",
+            group.reminder_texts,
+        )
+        has_text = merged_text.strip() != ""
+
+        images = list(group.tool_result.images or []) + list(group.reminder_images)
+        image_parts: list[types.Part] = []
+        for image in images:
+            try:
+                image_parts.append(_image_part_to_part(image))
+            except ValueError:
+                # Skip invalid data URLs
+                continue
+
+        has_images = len(image_parts) > 0
+        response_value = merged_text if has_text else "(see attached image)" if has_images else ""
+        response_payload = (
+            {"error": response_value} if group.tool_result.status == "error" else {"output": response_value}
+        )
+
+        function_response = types.FunctionResponse(
+            id=group.tool_result.call_id,
+            name=group.tool_result.tool_name or "",
+            response=response_payload,
+            parts=image_parts if (has_images and supports_multimodal_function_response) else None,
+        )
+        response_parts.append(types.Part(function_response=function_response))
+
+        if has_images and not supports_multimodal_function_response:
+            extra_image_contents.append(
+                types.Content(role="user", parts=[types.Part(text="Tool result image:"), *image_parts])
+            )
+
+    contents: list[types.Content] = []
+    if response_parts:
+        contents.append(types.Content(role="user", parts=response_parts))
+    contents.extend(extra_image_contents)
+    return contents
+
+
+def _assistant_group_to_content(group: AssistantGroup, model_name: str | None) -> types.Content | None:
+    parts: list[types.Part] = []
+
+    degraded_thinking_texts: list[str] = []
+    pending_thought_text: str | None = None
+    pending_thought_signature: str | None = None
+
+    for item in group.reasoning_items:
+        match item:
+            case model.ReasoningTextItem():
+                if not item.content:
+                    continue
+                if model_name is not None and item.model is not None and item.model != model_name:
+                    degraded_thinking_texts.append(item.content)
+                else:
+                    pending_thought_text = item.content
+            case model.ReasoningEncryptedItem():
+                if not (
+                    model_name is not None
+                    and item.model == model_name
+                    and item.encrypted_content
+                    and (item.format or "").startswith("google")
+                    and pending_thought_text
+                ):
+                    continue
+                pending_thought_signature = item.encrypted_content
+                parts.append(
+                    types.Part(
+                        text=pending_thought_text,
+                        thought=True,
+                        thought_signature=pending_thought_signature,
+                    )
+                )
+                pending_thought_text = None
+                pending_thought_signature = None
+
+    if pending_thought_text:
+        parts.append(
+            types.Part(
+                text=pending_thought_text,
+                thought=True,
+                thought_signature=pending_thought_signature,
+            )
+        )
+
+    if degraded_thinking_texts:
+        parts.insert(0, types.Part(text="<thinking>\n" + "\n".join(degraded_thinking_texts) + "\n</thinking>"))
+
+    if group.text_content:
+        parts.append(types.Part(text=group.text_content))
+
+    for tc in group.tool_calls:
+        args: dict[str, Any]
+        if tc.arguments:
+            try:
+                args = json.loads(tc.arguments)
+            except json.JSONDecodeError:
+                args = {"_raw": tc.arguments}
+        else:
+            args = {}
+        parts.append(types.Part(function_call=types.FunctionCall(id=tc.call_id, name=tc.name, args=args)))
+
+    if not parts:
+        return None
+    return types.Content(role="model", parts=parts)
+
+
+def convert_history_to_contents(
+    history: list[model.ConversationItem],
+    model_name: str | None,
+) -> list[types.Content]:
+    contents: list[types.Content] = []
+    pending_tool_groups: list[ToolGroup] = []
+
+    def flush_tool_groups() -> None:
+        nonlocal pending_tool_groups
+        if pending_tool_groups:
+            contents.extend(_tool_groups_to_content(pending_tool_groups, model_name=model_name))
+            pending_tool_groups = []
+
+    for group in parse_message_groups(history):
+        match group:
+            case UserGroup():
+                flush_tool_groups()
+                contents.append(_user_group_to_content(group))
+            case ToolGroup():
+                pending_tool_groups.append(group)
+            case AssistantGroup():
+                flush_tool_groups()
+                content = _assistant_group_to_content(group, model_name=model_name)
+                if content is not None:
+                    contents.append(content)
+
+    flush_tool_groups()
+    return contents
+
+
+def convert_tool_schema(tools: list[llm_param.ToolSchema] | None) -> list[types.Tool]:
+    if tools is None or len(tools) == 0:
+        return []
+    declarations = [
+        types.FunctionDeclaration(
+            name=tool.name,
+            description=tool.description,
+            parameters_json_schema=tool.parameters,
+        )
+        for tool in tools
+    ]
+    return [types.Tool(function_declarations=declarations)]

klaude_code/llm/registry.py

@@ -1,3 +1,4 @@
+import importlib
 from collections.abc import Callable
 from typing import TYPE_CHECKING, TypeVar
 
@@ -21,15 +22,19 @@ def _load_protocol(protocol: llm_param.LLMClientProtocol) -> None:
 
     # Import only the needed module to trigger @register decorator
     if protocol == llm_param.LLMClientProtocol.ANTHROPIC:
-        from . import anthropic as _
+        importlib.import_module("klaude_code.llm.anthropic")
+    elif protocol == llm_param.LLMClientProtocol.BEDROCK:
+        importlib.import_module("klaude_code.llm.bedrock")
     elif protocol == llm_param.LLMClientProtocol.CODEX:
-        from . import codex as _
+        importlib.import_module("klaude_code.llm.codex")
     elif protocol == llm_param.LLMClientProtocol.OPENAI:
-        from . import openai_compatible as _
+        importlib.import_module("klaude_code.llm.openai_compatible")
     elif protocol == llm_param.LLMClientProtocol.OPENROUTER:
-        from . import openrouter as _
+        importlib.import_module("klaude_code.llm.openrouter")
     elif protocol == llm_param.LLMClientProtocol.RESPONSES:
-        from . import responses as _  # noqa: F401
+        importlib.import_module("klaude_code.llm.responses")
+    elif protocol == llm_param.LLMClientProtocol.GOOGLE:
+        importlib.import_module("klaude_code.llm.google")
 
 
 def register(name: llm_param.LLMClientProtocol) -> Callable[[_T], _T]:

klaude_code/llm/usage.py

@@ -81,7 +81,7 @@ class MetadataTracker:
             ) * 1000
 
             if self._last_token_time is not None and self._metadata_item.usage.output_tokens > 0:
-                time_duration = self._last_token_time - self._first_token_time
+                time_duration = self._last_token_time - self._request_start_time
                 if time_duration >= 0.15:
                     self._metadata_item.usage.throughput_tps = self._metadata_item.usage.output_tokens / time_duration
 

klaude_code/protocol/llm_param.py

@@ -12,7 +12,9 @@ class LLMClientProtocol(Enum):
     RESPONSES = "responses"
     OPENROUTER = "openrouter"
     ANTHROPIC = "anthropic"
+    BEDROCK = "bedrock"
     CODEX = "codex"
+    GOOGLE = "google"
 
 
 class ToolSchema(BaseModel):
@@ -91,8 +93,15 @@ class LLMConfigProviderParameter(BaseModel):
     protocol: LLMClientProtocol
     base_url: str | None = None
     api_key: str | None = None
+    # Azure OpenAI
     is_azure: bool = False
     azure_api_version: str | None = None
+    # AWS Bedrock configuration
+    aws_access_key: str | None = None
+    aws_secret_key: str | None = None
+    aws_region: str | None = None
+    aws_session_token: str | None = None
+    aws_profile: str | None = None
 
 
 class LLMConfigModelParameter(BaseModel):

klaude_code/session/__init__.py

@@ -1,4 +1,4 @@
-from .selector import SessionSelectOption, build_session_select_options
+from .selector import SessionSelectOption, build_session_select_options, format_user_messages_display
 from .session import Session
 
-__all__ = ["Session", "SessionSelectOption", "build_session_select_options"]
+__all__ = ["Session", "SessionSelectOption", "build_session_select_options", "format_user_messages_display"]

klaude_code/session/selector.py

@@ -33,12 +33,39 @@ class SessionSelectOption:
     """Option data for session selection UI."""
 
     session_id: str
-    first_user_message: str
+    user_messages: list[str]
     messages_count: str
     relative_time: str
     model_name: str
 
 
+def _format_message(msg: str) -> str:
+    """Format a user message for display (strip and collapse newlines)."""
+    return msg.strip().replace("\n", " ")
+
+
+def format_user_messages_display(messages: list[str]) -> list[str]:
+    """Format user messages for display in session selection.
+
+    Shows up to 6 messages. If more than 6, shows first 3 and last 3 with ellipsis.
+    Each message is on its own line.
+
+    Args:
+        messages: List of user messages.
+
+    Returns:
+        List of formatted message lines for display.
+    """
+    if len(messages) <= 6:
+        return messages
+
+    # More than 6: show first 3, ellipsis, last 3
+    result = messages[:3]
+    result.append("⋮")
+    result.extend(messages[-3:])
+    return result
+
+
 def build_session_select_options() -> list[SessionSelectOption]:
     """Build session selection options data.
 
@@ -51,8 +78,9 @@ def build_session_select_options() -> list[SessionSelectOption]:
 
     options: list[SessionSelectOption] = []
     for s in sessions:
-        first_msg = s.first_user_message or "N/A"
-        first_msg = first_msg.strip().replace("\n", " ")
+        user_messages = [_format_message(m) for m in s.user_messages if m.strip()]
+        if not user_messages:
+            user_messages = ["N/A"]
 
         msg_count = "N/A" if s.messages_count == -1 else f"{s.messages_count} messages"
         model = s.model_name or "N/A"
@@ -60,7 +88,7 @@ def build_session_select_options() -> list[SessionSelectOption]:
         options.append(
             SessionSelectOption(
                 session_id=str(s.id),
-                first_user_message=first_msg,
+                user_messages=user_messages,
                 messages_count=msg_count,
                 relative_time=_relative_time(s.updated_at),
                 model_name=model,

klaude_code/session/session.py

@@ -197,11 +197,16 @@ class Session(BaseModel):
         )
         self._store.append_and_flush(session_id=self.id, items=items, meta=meta)
 
-    def fork(self, *, new_id: str | None = None) -> Session:
+    def fork(self, *, new_id: str | None = None, until_index: int | None = None) -> Session:
         """Create a new session as a fork of the current session.
 
         The forked session copies metadata and conversation history, but does not
         modify the current session.
+
+        Args:
+            new_id: Optional ID for the forked session.
+            until_index: If provided, only copy conversation history up to (but not including) this index.
+                         If None, copy all history.
         """
 
         forked = Session.create(id=new_id, work_dir=self.work_dir)
@@ -213,7 +218,10 @@ class Session(BaseModel):
         forked.file_tracker = {k: v.model_copy(deep=True) for k, v in self.file_tracker.items()}
         forked.todos = [todo.model_copy(deep=True) for todo in self.todos]
 
-        items = [it.model_copy(deep=True) for it in self.conversation_history]
+        history_to_copy = (
+            self.conversation_history[:until_index] if until_index is not None else self.conversation_history
+        )
+        items = [it.model_copy(deep=True) for it in history_to_copy]
         if items:
             forked.append_history(items)
 
@@ -338,7 +346,7 @@ class Session(BaseModel):
         updated_at: float
         work_dir: str
         path: str
-        first_user_message: str | None = None
+        user_messages: list[str] = []
         messages_count: int = -1
         model_name: str | None = None
 
@@ -346,10 +354,11 @@ class Session(BaseModel):
     def list_sessions(cls) -> list[SessionMetaBrief]:
         store = get_default_store()
 
-        def _get_first_user_message(session_id: str) -> str | None:
+        def _get_user_messages(session_id: str) -> list[str]:
             events_path = store.paths.events_file(session_id)
             if not events_path.exists():
-                return None
+                return []
+            messages: list[str] = []
             try:
                 for line in events_path.read_text(encoding="utf-8").splitlines():
                     obj_raw = json.loads(line)
@@ -360,15 +369,14 @@ class Session(BaseModel):
                         continue
                     data_raw = obj.get("data")
                     if not isinstance(data_raw, dict):
-                        return None
+                        continue
                     data = cast(dict[str, Any], data_raw)
                     content = data.get("content")
                     if isinstance(content, str):
-                        return content
-                    return None
+                        messages.append(content)
             except (OSError, json.JSONDecodeError):
-                return None
-            return None
+                pass
+            return messages
 
         items: list[Session.SessionMetaBrief] = []
         for meta_path in store.iter_meta_files():
@@ -382,7 +390,7 @@ class Session(BaseModel):
             created = float(data.get("created_at", meta_path.stat().st_mtime))
             updated = float(data.get("updated_at", meta_path.stat().st_mtime))
             work_dir = str(data.get("work_dir", ""))
-            first_user_message = _get_first_user_message(sid)
+            user_messages = _get_user_messages(sid)
             messages_count = int(data.get("messages_count", -1))
             model_name = data.get("model_name") if isinstance(data.get("model_name"), str) else None
 
@@ -393,7 +401,7 @@ class Session(BaseModel):
                     updated_at=updated,
                     work_dir=work_dir,
                     path=str(meta_path),
-                    first_user_message=first_user_message,
+                    user_messages=user_messages,
                     messages_count=messages_count,
                     model_name=model_name,
                 )

klaude_code/ui/modes/repl/event_handler.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
-from rich.cells import cell_len
 from rich.rule import Rule
 from rich.text import Text
 
@@ -265,11 +264,27 @@ class SpinnerStatusState:
 
         return result
 
-    def get_context_text(self) -> Text | None:
-        """Get context usage text for right-aligned display."""
-        if self._context_percent is None:
+    def get_right_text(self) -> r_status.DynamicText | None:
+        """Get right-aligned status text (elapsed time and optional context %)."""
+
+        elapsed_text = r_status.current_elapsed_text()
+        has_context = self._context_percent is not None
+
+        if elapsed_text is None and not has_context:
             return None
-        return Text(f"{self._context_percent:.1f}%", style=ThemeKey.METADATA_DIM)
+
+        def _render() -> Text:
+            parts: list[str] = []
+            if self._context_percent is not None:
+                parts.append(f"{self._context_percent:.1f}%")
+            current_elapsed = r_status.current_elapsed_text()
+            if current_elapsed is not None:
+                if parts:
+                    parts.append(" · ")
+                parts.append(current_elapsed)
+            return Text("".join(parts), style=ThemeKey.METADATA_DIM)
+
+        return r_status.DynamicText(_render)
 
 
 class DisplayEventHandler:
@@ -550,11 +565,10 @@ class DisplayEventHandler:
     def _update_spinner(self) -> None:
         """Update spinner text from current status state."""
         status_text = self.spinner_status.get_status()
-        context_text = self.spinner_status.get_context_text()
-        status_text = self._truncate_spinner_status_text(status_text, right_text=context_text)
+        right_text = self.spinner_status.get_right_text()
         self.renderer.spinner_update(
             status_text,
-            context_text,
+            right_text,
         )
 
     async def _flush_assistant_buffer(self, state: StreamState) -> None:
@@ -612,27 +626,3 @@ class DisplayEventHandler:
                 if len(todo.content) > 0:
                     status_text = todo.content
         return status_text.replace("\n", " ").strip()
-
-    def _truncate_spinner_status_text(self, status_text: Text, *, right_text: Text | None) -> Text:
-        """Truncate spinner status to a single line based on terminal width.
-
-        Rich wraps based on terminal cell width (CJK chars count as 2). Use
-        cell-aware truncation to prevent the status from wrapping into two lines.
-        """
-
-        terminal_width = self.renderer.console.size.width
-
-        # BreathingSpinner renders as a 2-column Table.grid(padding=1):
-        # 1 cell for glyph + 1 cell of padding between columns (collapsed).
-        spinner_prefix_cells = 2
-
-        hint_cells = cell_len(r_status.current_hint_text())
-        right_cells = cell_len(right_text.plain) if right_text is not None else 0
-
-        max_main_cells = terminal_width - spinner_prefix_cells - hint_cells - right_cells - 1
-        # rich.text.Text.truncate behaves unexpectedly for 0; clamp to at least 1.
-        max_main_cells = max(1, max_main_cells)
-
-        truncated = status_text.copy()
-        truncated.truncate(max_main_cells, overflow="ellipsis", pad=False)
-        return truncated

klaude_code/ui/modes/repl/renderer.py

@@ -283,7 +283,7 @@ class REPLRenderer:
         self._spinner_visible = False
         self._refresh_bottom_live()
 
-    def spinner_update(self, status_text: str | Text, right_text: Text | None = None) -> None:
+    def spinner_update(self, status_text: str | Text, right_text: RenderableType | None = None) -> None:
         """Update the spinner status text with optional right-aligned text."""
         self._status_text = ShimmerStatusText(status_text, right_text)
         self._status_spinner.update(text=SingleLine(self._status_text), style=ThemeKey.STATUS_SPINNER)

klaude_code/ui/renderers/developer.py

@@ -161,10 +161,10 @@ def _format_cost(cost: float | None, currency: str = "USD") -> str:
 def _render_fork_session_output(command_output: model.CommandOutput) -> RenderableType:
     """Render fork session output with usage instructions."""
     if not isinstance(command_output.ui_extra, model.SessionIdUIExtra):
-        return Text("(no session id)", style=ThemeKey.METADATA)
+        return Padding.indent(Text("(no session id)", style=ThemeKey.METADATA), level=2)
 
-    session_id = command_output.ui_extra.session_id
     grid = Table.grid(padding=(0, 1))
+    session_id = command_output.ui_extra.session_id
     grid.add_column(style=ThemeKey.METADATA, overflow="fold")
 
     grid.add_row(Text("Session forked. To continue in a new conversation:", style=ThemeKey.METADATA))

klaude_code/ui/renderers/metadata.py

@@ -6,6 +6,7 @@ from rich.padding import Padding
 from rich.panel import Panel
 from rich.text import Text
 
+from klaude_code import const
 from klaude_code.protocol import events, model
 from klaude_code.trace import is_debug_enabled
 from klaude_code.ui.renderers.common import create_grid
@@ -95,10 +96,17 @@ def _render_task_metadata_block(
         # Context (only for main agent)
         if show_context_and_time and metadata.usage.context_usage_percent is not None:
             context_size = format_number(metadata.usage.context_size or 0)
+            # Calculate effective limit (same as Usage.context_usage_percent)
+            effective_limit = (metadata.usage.context_limit or 0) - (
+                metadata.usage.max_tokens or const.DEFAULT_MAX_TOKENS
+            )
+            effective_limit_str = format_number(effective_limit) if effective_limit > 0 else "?"
             parts.append(
                 Text.assemble(
                     ("context ", ThemeKey.METADATA_DIM),
                     (context_size, ThemeKey.METADATA),
+                    ("/", ThemeKey.METADATA_DIM),
+                    (effective_limit_str, ThemeKey.METADATA),
                     (f" ({metadata.usage.context_usage_percent:.1f}%)", ThemeKey.METADATA_DIM),
                 )
             )

klaude_code/ui/rich/markdown.py

@@ -254,18 +254,36 @@ class MarkdownStream:
         live suffix separately may introduce an extra blank line that wouldn't
         appear when rendering the full document.
 
-        This function removes leading blank lines from the live ANSI when the
-        stable ANSI already ends with a blank line.
+        This function removes *overlapping* blank lines from the live ANSI when
+        the stable ANSI already ends with one or more blank lines.
+
+        Important: don't remove *all* leading blank lines from the live suffix.
+        In some incomplete-block cases, the live render may begin with multiple
+        blank lines while the full-document render would keep one of them.
         """
 
         stable_lines = stable_ansi.splitlines(keepends=True)
-        stable_ends_blank = bool(stable_lines) and not stable_lines[-1].strip()
-        if not stable_ends_blank:
+        if not stable_lines:
+            return live_ansi
+
+        stable_trailing_blank = 0
+        for line in reversed(stable_lines):
+            if line.strip():
+                break
+            stable_trailing_blank += 1
+        if stable_trailing_blank <= 0:
             return live_ansi
 
         live_lines = live_ansi.splitlines(keepends=True)
-        while live_lines and not live_lines[0].strip():
-            live_lines.pop(0)
+        live_leading_blank = 0
+        for line in live_lines:
+            if line.strip():
+                break
+            live_leading_blank += 1
+
+        drop = min(stable_trailing_blank, live_leading_blank)
+        if drop > 0:
+            live_lines = live_lines[drop:]
         return "".join(live_lines)
 
     def _append_nonfinal_sentinel(self, stable_source: str) -> str:
@@ -400,9 +418,23 @@ class MarkdownStream:
             apply_mark_live = self._stable_source_line_count == 0
             live_lines = self._render_markdown_to_lines(live_source, apply_mark=apply_mark_live)
 
-            if self._stable_rendered_lines and not self._stable_rendered_lines[-1].strip():
-                while live_lines and not live_lines[0].strip():
-                    live_lines.pop(0)
+            if self._stable_rendered_lines:
+                stable_trailing_blank = 0
+                for line in reversed(self._stable_rendered_lines):
+                    if line.strip():
+                        break
+                    stable_trailing_blank += 1
+
+                if stable_trailing_blank > 0:
+                    live_leading_blank = 0
+                    for line in live_lines:
+                        if line.strip():
+                            break
+                        live_leading_blank += 1
+
+                    drop = min(stable_trailing_blank, live_leading_blank)
+                    if drop > 0:
+                        live_lines = live_lines[drop:]
 
             live_text = Text.from_ansi("".join(live_lines))
             self._live_sink(live_text)