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

klaude_code/cli/list_model.py

@@ -6,7 +6,7 @@ from rich.table import Table
 from rich.text import Text
 
 from klaude_code.config import Config
-from klaude_code.config.config import ModelConfig, ProviderConfig
+from klaude_code.config.config import ModelConfig, ProviderConfig, parse_env_var_syntax
 from klaude_code.protocol.llm_param import LLMClientProtocol
 from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
 from klaude_code.ui.rich.theme import ThemeKey, get_theme
@@ -94,6 +94,29 @@ def format_api_key_display(provider: ProviderConfig) -> Text:
         return Text("N/A")
 
 
+def format_env_var_display(value: str | None) -> Text:
+    """Format environment variable display with warning if not set."""
+    env_var, resolved = parse_env_var_syntax(value)
+
+    if env_var:
+        # Using ${ENV_VAR} syntax
+        if resolved:
+            return Text.assemble(
+                (f"${{{env_var}}} = ", "dim"),
+                (mask_api_key(resolved), ""),
+            )
+        else:
+            return Text.assemble(
+                (f"${{{env_var}}} ", ""),
+                ("(not set)", ThemeKey.CONFIG_STATUS_ERROR),
+            )
+    elif value:
+        # Plain value
+        return Text(mask_api_key(value))
+    else:
+        return Text("N/A")
+
+
 def _get_model_params_display(model: ModelConfig) -> list[Text]:
     """Get display elements for model parameters."""
     params: list[Text] = []
@@ -162,15 +185,43 @@ def display_models_and_providers(config: Config):
                 format_api_key_display(provider),
             )
 
+        # AWS Bedrock parameters
+        if provider.protocol == LLMClientProtocol.BEDROCK:
+            if provider.aws_access_key:
+                provider_info.add_row(
+                    Text("AWS Key:", style=ThemeKey.CONFIG_PARAM_LABEL),
+                    format_env_var_display(provider.aws_access_key),
+                )
+            if provider.aws_secret_key:
+                provider_info.add_row(
+                    Text("AWS Secret:", style=ThemeKey.CONFIG_PARAM_LABEL),
+                    format_env_var_display(provider.aws_secret_key),
+                )
+            if provider.aws_region:
+                provider_info.add_row(
+                    Text("AWS Region:", style=ThemeKey.CONFIG_PARAM_LABEL),
+                    format_env_var_display(provider.aws_region),
+                )
+            if provider.aws_session_token:
+                provider_info.add_row(
+                    Text("AWS Token:", style=ThemeKey.CONFIG_PARAM_LABEL),
+                    format_env_var_display(provider.aws_session_token),
+                )
+            if provider.aws_profile:
+                provider_info.add_row(
+                    Text("AWS Profile:", style=ThemeKey.CONFIG_PARAM_LABEL),
+                    format_env_var_display(provider.aws_profile),
+                )
+
         # Check if provider has valid API key
         provider_available = not provider.is_api_key_missing()
 
         # Models table for this provider
         models_table = Table.grid(padding=(0, 1), expand=True)
         models_table.add_column(width=2, no_wrap=True)  # Status
-        models_table.add_column(overflow="fold", ratio=1)  # Name
-        models_table.add_column(overflow="fold", ratio=2)  # Model
-        models_table.add_column(overflow="fold", ratio=3)  # Params
+        models_table.add_column(overflow="fold", ratio=2)  # Name
+        models_table.add_column(overflow="fold", ratio=3)  # Model
+        models_table.add_column(overflow="fold", ratio=4)  # Params
 
         # Add header
         models_table.add_row(

klaude_code/cli/main.py

@@ -11,64 +11,11 @@ from klaude_code.cli.config_cmd import register_config_commands
 from klaude_code.cli.debug import DEBUG_FILTER_HELP, open_log_file_in_editor, resolve_debug_settings
 from klaude_code.cli.self_update import register_self_update_commands, version_option_callback
 from klaude_code.cli.session_cmd import register_session_commands
-from klaude_code.session import Session, build_session_select_options
+from klaude_code.command.resume_cmd import select_session_sync
+from klaude_code.session import Session
 from klaude_code.trace import DebugType, prepare_debug_log_file
 
 
-def select_session_interactive() -> str | None:
-    """Interactive session selection for CLI.
-
-    Returns:
-        Selected session ID, or None if no session selected or no sessions exist.
-    """
-    from klaude_code.trace import log
-
-    options = build_session_select_options()
-    if not options:
-        log("No sessions found for this project.")
-        return None
-
-    from prompt_toolkit.styles import Style
-
-    from klaude_code.ui.terminal.selector import SelectItem, select_one
-
-    items: list[SelectItem[str]] = []
-    for opt in options:
-        title = [
-            ("class:msg", f"{opt.first_user_message}\n"),
-            ("class:meta", f"   {opt.messages_count} · {opt.relative_time} · {opt.model_name} · {opt.session_id}\n\n"),
-        ]
-        items.append(
-            SelectItem(
-                title=title,
-                value=opt.session_id,
-                search_text=f"{opt.first_user_message} {opt.model_name} {opt.session_id}",
-            )
-        )
-
-    try:
-        return select_one(
-            message="Select a session to resume:",
-            items=items,
-            pointer="→",
-            style=Style(
-                [
-                    ("msg", ""),
-                    ("meta", "fg:ansibrightblack"),
-                    ("pointer", "bold fg:ansigreen"),
-                    ("highlighted", "fg:ansigreen"),
-                    ("search_prefix", "fg:ansibrightblack"),
-                    ("search_success", "noinherit fg:ansigreen"),
-                    ("search_none", "noinherit fg:ansired"),
-                    ("question", "bold"),
-                    ("text", ""),
-                ]
-            ),
-        )
-    except KeyboardInterrupt:
-        return None
-
-
 def set_terminal_title(title: str) -> None:
     """Set terminal window title using ANSI escape sequence."""
     # Never write terminal control sequences when stdout is not a TTY (pipes/CI/redirects).
@@ -361,7 +308,7 @@ def main_callback(
         session_id: str | None = None
 
         if resume:
-            session_id = select_session_interactive()
+            session_id = select_session_sync()
             if session_id is None:
                 return
         # If user didn't pick, allow fallback to --continue

klaude_code/cli/session_cmd.py

@@ -22,8 +22,9 @@ def _session_confirm(sessions: list[Session.SessionMetaBrief], message: str) ->
     log(f"Sessions to delete ({len(sessions)}):")
     for s in sessions:
         msg_count_display = "N/A" if s.messages_count == -1 else str(s.messages_count)
-        first_msg = (s.first_user_message or "").strip().replace("\n", " ")[:50]
-        if len(s.first_user_message or "") > 50:
+        first_msg_text = s.user_messages[0] if s.user_messages else ""
+        first_msg = first_msg_text.strip().replace("\n", " ")[:50]
+        if len(first_msg_text) > 50:
             first_msg += "..."
         log(f"  {_fmt(s.updated_at)}  {msg_count_display:>3} msgs  {first_msg}")
 

klaude_code/command/fork_session_cmd.py

@@ -1,5 +1,182 @@
+import asyncio
+import sys
+from dataclasses import dataclass
+from typing import Literal
+
+from prompt_toolkit.styles import Style
+
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model
+from klaude_code.ui.terminal.selector import SelectItem, select_one
+
+FORK_SELECT_STYLE = Style(
+    [
+        ("msg", ""),
+        ("meta", "fg:ansibrightblack"),
+        ("separator", "fg:ansibrightblack"),
+        ("assistant", "fg:ansiblue"),
+        ("pointer", "bold fg:ansigreen"),
+        ("search_prefix", "fg:ansibrightblack"),
+        ("search_success", "noinherit fg:ansigreen"),
+        ("search_none", "noinherit fg:ansired"),
+        ("question", "bold"),
+        ("text", ""),
+    ]
+)
+
+
+@dataclass
+class ForkPoint:
+    """A fork point in conversation history."""
+
+    history_index: int | None  # None means fork entire conversation
+    user_message: str
+    tool_call_stats: dict[str, int]  # tool_name -> count
+    last_assistant_summary: str
+
+
+def _truncate(text: str, max_len: int = 60) -> str:
+    """Truncate text to max_len, adding ellipsis if needed."""
+    text = text.replace("\n", " ").strip()
+    if len(text) <= max_len:
+        return text
+    return text[: max_len - 3] + "..."
+
+
+def _build_fork_points(conversation_history: list[model.ConversationItem]) -> list[ForkPoint]:
+    """Build list of fork points from conversation history.
+
+    Fork points are:
+    - Each UserMessageItem position (for UI display, including first which would be empty session)
+    - The end of the conversation (fork entire conversation)
+    """
+    fork_points: list[ForkPoint] = []
+    user_indices: list[int] = []
+
+    for i, item in enumerate(conversation_history):
+        if isinstance(item, model.UserMessageItem):
+            user_indices.append(i)
+
+    # For each UserMessageItem, create a fork point at that position
+    for i, user_idx in enumerate(user_indices):
+        user_item = conversation_history[user_idx]
+        assert isinstance(user_item, model.UserMessageItem)
+
+        # Find the end of this "task" (next UserMessageItem or end of history)
+        next_user_idx = user_indices[i + 1] if i + 1 < len(user_indices) else len(conversation_history)
+
+        # Count tool calls by name and find last assistant message in this segment
+        tool_stats: dict[str, int] = {}
+        last_assistant_content = ""
+        for j in range(user_idx, next_user_idx):
+            item = conversation_history[j]
+            if isinstance(item, model.ToolCallItem):
+                tool_stats[item.name] = tool_stats.get(item.name, 0) + 1
+            elif isinstance(item, model.AssistantMessageItem) and item.content:
+                last_assistant_content = item.content
+
+        fork_points.append(
+            ForkPoint(
+                history_index=user_idx,
+                user_message=user_item.content or "(empty)",
+                tool_call_stats=tool_stats,
+                last_assistant_summary=_truncate(last_assistant_content) if last_assistant_content else "",
+            )
+        )
+
+    # Add the "fork entire conversation" option at the end
+    if user_indices:
+        fork_points.append(
+            ForkPoint(
+                history_index=None,  # None means fork entire conversation
+                user_message="",  # No specific message, this represents the end
+                tool_call_stats={},
+                last_assistant_summary="",
+            )
+        )
+
+    return fork_points
+
+
+def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int | None]]:
+    """Build SelectItem list from fork points."""
+    items: list[SelectItem[int | None]] = []
+
+    for i, fp in enumerate(fork_points):
+        is_first = i == 0
+        is_last = i == len(fork_points) - 1
+
+        # Build the title
+        title_parts: list[tuple[str, str]] = []
+
+        # First line: separator (with special markers for first/last fork points)
+        if is_first and not is_last:
+            title_parts.append(("class:separator", "----- fork from here (empty session) -----\n\n"))
+        elif is_last:
+            title_parts.append(("class:separator", "----- fork from here (entire session) -----\n\n"))
+        else:
+            title_parts.append(("class:separator", "----- fork from here -----\n\n"))
+
+        if not is_last:
+            # Second line: user message
+            title_parts.append(("class:msg", f"user:   {_truncate(fp.user_message, 70)}\n"))
+
+            # Third line: tool call stats (if any)
+            if fp.tool_call_stats:
+                tool_parts = [f"{name} × {count}" for name, count in fp.tool_call_stats.items()]
+                title_parts.append(("class:meta", f"tools:  {', '.join(tool_parts)}\n"))
+
+            # Fourth line: last assistant message summary (if any)
+            if fp.last_assistant_summary:
+                title_parts.append(("class:assistant", f"ai:     {fp.last_assistant_summary}\n"))
+
+        # Empty line at the end
+        title_parts.append(("class:text", "\n"))
+
+        items.append(
+            SelectItem(
+                title=title_parts,
+                value=fp.history_index,
+                search_text=fp.user_message if not is_last else "fork entire conversation",
+            )
+        )
+
+    return items
+
+
+def _select_fork_point_sync(fork_points: list[ForkPoint]) -> int | None | Literal["cancelled"]:
+    """Interactive fork point selection (sync version for asyncio.to_thread).
+
+    Returns:
+        - int: history index to fork at (exclusive)
+        - None: fork entire conversation
+        - "cancelled": user cancelled selection
+    """
+    items = _build_select_items(fork_points)
+    if not items:
+        return None
+
+    # Default to the last option (fork entire conversation)
+    last_value = items[-1].value
+
+    # Non-interactive environments default to forking entire conversation
+    if not sys.stdin.isatty() or not sys.stdout.isatty():
+        return last_value
+
+    try:
+        result = select_one(
+            message="Select fork point (messages before this point will be included):",
+            items=items,
+            pointer="→",
+            style=FORK_SELECT_STYLE,
+            initial_value=last_value,
+            highlight_pointed_item=False,
+        )
+        if result is None:
+            return "cancelled"
+        return result
+    except KeyboardInterrupt:
+        return "cancelled"
 
 
 class ForkSessionCommand(CommandABC):
@@ -13,6 +190,10 @@ class ForkSessionCommand(CommandABC):
     def summary(self) -> str:
         return "Fork the current session and show a resume-by-id command"
 
+    @property
+    def is_interactive(self) -> bool:
+        return True
+
     async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
         del user_input  # unused
 
@@ -26,13 +207,50 @@ class ForkSessionCommand(CommandABC):
             )
             return CommandResult(events=[event], persist_user_input=False, persist_events=False)
 
-        new_session = agent.session.fork()
+        # Build fork points from conversation history
+        fork_points = _build_fork_points(agent.session.conversation_history)
+
+        if not fork_points:
+            # Only one user message, just fork entirely
+            new_session = agent.session.fork()
+            await new_session.wait_for_flush()
+
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content=f"Session forked successfully. New session id: {new_session.id}",
+                    command_output=model.CommandOutput(
+                        command_name=self.name,
+                        ui_extra=model.SessionIdUIExtra(session_id=new_session.id),
+                    ),
+                ),
+            )
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+
+        # Interactive selection
+        selected = await asyncio.to_thread(_select_fork_point_sync, fork_points)
+
+        if selected == "cancelled":
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content="(fork cancelled)",
+                    command_output=model.CommandOutput(command_name=self.name),
+                ),
+            )
+            return CommandResult(events=[event], persist_user_input=False, persist_events=False)
+
+        # Perform the fork
+        new_session = agent.session.fork(until_index=selected)
         await new_session.wait_for_flush()
 
+        # Build result message
+        fork_description = "entire conversation" if selected is None else f"up to message index {selected}"
+
         event = events.DeveloperMessageEvent(
             session_id=agent.session.id,
             item=model.DeveloperMessageItem(
-                content=f"Session forked successfully. New session id: {new_session.id}",
+                content=f"Session forked ({fork_description}). New session id: {new_session.id}",
                 command_output=model.CommandOutput(
                     command_name=self.name,
                     ui_extra=model.SessionIdUIExtra(session_id=new_session.id),

klaude_code/command/refresh_cmd.py

@@ -23,7 +23,7 @@ class RefreshTerminalCommand(CommandABC):
 
         os.system("cls" if os.name == "nt" else "clear")
 
-        result = CommandResult(
+        return CommandResult(
             events=[
                 events.WelcomeEvent(
                     work_dir=str(agent.session.work_dir),
@@ -35,7 +35,7 @@ class RefreshTerminalCommand(CommandABC):
                     updated_at=agent.session.updated_at,
                     is_load=False,
                 ),
-            ]
+            ],
+            persist_user_input=False,
+            persist_events=False,
         )
-
-        return result

klaude_code/command/resume_cmd.py

@@ -4,14 +4,14 @@ from prompt_toolkit.styles import Style
 
 from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model, op
-from klaude_code.session.selector import build_session_select_options
+from klaude_code.session.selector import build_session_select_options, format_user_messages_display
 from klaude_code.trace import log
 from klaude_code.ui.terminal.selector import SelectItem, select_one
 
 SESSION_SELECT_STYLE = Style(
     [
-        ("msg", ""),
-        ("meta", "fg:ansibrightblack"),
+        ("msg", "fg:ansibrightblack"),
+        ("meta", ""),
         ("pointer", "bold fg:ansigreen"),
         ("highlighted", "fg:ansigreen"),
         ("search_prefix", "fg:ansibrightblack"),
@@ -23,7 +23,7 @@ SESSION_SELECT_STYLE = Style(
 )
 
 
-def _select_session_sync() -> str | None:
+def select_session_sync() -> str | None:
     """Interactive session selection (sync version for asyncio.to_thread)."""
     options = build_session_select_options()
     if not options:
@@ -31,16 +31,26 @@ def _select_session_sync() -> str | None:
         return None
 
     items: list[SelectItem[str]] = []
-    for opt in options:
-        title = [
-            ("class:msg", f"{opt.first_user_message}\n"),
-            ("class:meta", f"   {opt.messages_count} · {opt.relative_time} · {opt.model_name} · {opt.session_id}\n\n"),
-        ]
+    for idx, opt in enumerate(options, 1):
+        display_msgs = format_user_messages_display(opt.user_messages)
+        title: list[tuple[str, str]] = []
+        title.append(("fg:ansibrightblack", f"{idx:2}. "))
+        title.append(
+            ("class:meta", f"{opt.relative_time} · {opt.messages_count} · {opt.model_name} · {opt.session_id}\n")
+        )
+        for msg in display_msgs:
+            if msg == "⋮":
+                title.append(("class:msg", f"    {msg}\n"))
+            else:
+                title.append(("class:msg", f"    > {msg}\n"))
+        title.append(("", "\n"))
+
+        search_text = " ".join(opt.user_messages) + f" {opt.model_name} {opt.session_id}"
         items.append(
             SelectItem(
                 title=title,
                 value=opt.session_id,
-                search_text=f"{opt.first_user_message} {opt.model_name} {opt.session_id}",
+                search_text=search_text,
             )
         )
 
@@ -83,7 +93,7 @@ class ResumeCommand(CommandABC):
             )
             return CommandResult(events=[event], persist_user_input=False, persist_events=False)
 
-        selected_session_id = await asyncio.to_thread(_select_session_sync)
+        selected_session_id = await asyncio.to_thread(select_session_sync)
         if selected_session_id is None:
             event = events.DeveloperMessageEvent(
                 session_id=agent.session.id,

klaude_code/config/assets/builtin_config.yaml

@@ -7,7 +7,7 @@ provider_list:
   protocol: anthropic
   api_key: ${ANTHROPIC_API_KEY}
   model_list:
-  - model_name: sonnet
+  - model_name: sonnet@ant
     model_params:
       model: claude-sonnet-4-5-20250929
       context_limit: 200000
@@ -18,7 +18,7 @@ provider_list:
         output: 15.0
         cache_read: 0.3
         cache_write: 3.75
-  - model_name: opus
+  - model_name: opus@ant
     model_params:
       model: claude-opus-4-5-20251101
       context_limit: 200000
@@ -194,6 +194,41 @@ provider_list:
         output: 1.74
         cache_read: 0.04
 
+- provider_name: google
+  protocol: google
+  api_key: ${GOOGLE_API_KEY}
+  model_list:
+  - model_name: gemini-pro@google
+    model_params:
+      model: gemini-3-pro-preview
+      context_limit: 1048576
+      cost:
+        input: 2.0
+        output: 12.0
+        cache_read: 0.2
+  - model_name: gemini-flash@google
+    model_params:
+      model: gemini-3-flash-preview
+      context_limit: 1048576
+      cost:
+        input: 0.5
+        output: 3.0
+        cache_read: 0.05
+- provider_name: bedrock
+  protocol: bedrock
+  aws_access_key: ${AWS_ACCESS_KEY_ID}
+  aws_secret_key: ${AWS_SECRET_ACCESS_KEY}
+  aws_region: ${AWS_REGION}
+  model_list:
+  - model_name: sonnet@bedrock
+    model_params:
+      model: us.anthropic.claude-sonnet-4-5-20250929-v1:0
+      context_limit: 200000
+      cost:
+        input: 3.0
+        output: 15.0
+        cache_read: 0.3
+        cache_write: 3.75
 - provider_name: deepseek
   protocol: anthropic
   api_key: ${DEEPSEEK_API_KEY}

klaude_code/config/builtin_config.py

@@ -17,6 +17,7 @@ if TYPE_CHECKING:
 # All supported API key environment variables
 SUPPORTED_API_KEY_ENVS = [
     "ANTHROPIC_API_KEY",
+    "GOOGLE_API_KEY",
     "OPENAI_API_KEY",
     "OPENROUTER_API_KEY",
     "DEEPSEEK_API_KEY",

klaude_code/config/config.py

@@ -77,6 +77,7 @@ class ProviderConfig(llm_param.LLMConfigProviderParameter):
         """Check if the API key is missing (either not set or env var not found).
 
         For codex protocol, checks OAuth login status instead of API key.
+        For bedrock protocol, checks AWS credentials instead of API key.
         """
         from klaude_code.protocol.llm_param import LLMClientProtocol
 
@@ -89,6 +90,19 @@ class ProviderConfig(llm_param.LLMConfigProviderParameter):
             # Consider available if logged in and token not expired
             return state is None or state.is_expired()
 
+        if self.protocol == LLMClientProtocol.BEDROCK:
+            # Bedrock uses AWS credentials, not API key. Region is always required.
+            _, resolved_profile = parse_env_var_syntax(self.aws_profile)
+            _, resolved_region = parse_env_var_syntax(self.aws_region)
+
+            # When using profile, we still need region to initialize the client.
+            if resolved_profile:
+                return resolved_region is None
+
+            _, resolved_access_key = parse_env_var_syntax(self.aws_access_key)
+            _, resolved_secret_key = parse_env_var_syntax(self.aws_secret_key)
+            return resolved_region is None or resolved_access_key is None or resolved_secret_key is None
+
         return self.get_resolved_api_key() is None
 
 

klaude_code/config/thinking.py

@@ -121,6 +121,13 @@ def format_current_thinking(config: llm_param.LLMConfigParameter) -> str:
             return f"enabled (budget_tokens={thinking.budget_tokens})"
         return "not set"
 
+    if protocol == llm_param.LLMClientProtocol.GOOGLE:
+        if thinking.type == "disabled":
+            return "off"
+        if thinking.type == "enabled":
+            return f"enabled (budget_tokens={thinking.budget_tokens})"
+        return "not set"
+
     return "unknown protocol"
 
 
@@ -230,6 +237,13 @@ def get_thinking_picker_data(config: llm_param.LLMConfigParameter) -> ThinkingPi
             current_value=_get_current_budget_value(thinking),
         )
 
+    if protocol == llm_param.LLMClientProtocol.GOOGLE:
+        return ThinkingPickerData(
+            options=_build_budget_options(),
+            message="Select thinking level:",
+            current_value=_get_current_budget_value(thinking),
+        )
+
     return None