klaude-code 1.6.0__py3-none-any.whl → 1.7.1__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

@@ -95,10 +95,20 @@ def read_input_content(cli_argument: str) -> str | None:
     return content
 
 
+ENV_HELP = """\
+Environment Variables:
+
+  KLAUDE_READ_GLOBAL_LINE_CAP  Max lines to read (default: 2000)
+
+  KLAUDE_READ_MAX_CHARS        Max total chars to read (default: 50000)
+"""
+
 app = typer.Typer(
     add_completion=False,
     pretty_exceptions_enable=False,
     no_args_is_help=False,
+    rich_markup_mode="rich",
+    epilog=ENV_HELP,
 )
 
 # Register subcommands from modules

klaude_code/cli/runtime.py

@@ -379,7 +379,7 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
                 model_name=model_name,
                 save_as_default=False,
                 defer_thinking_selection=True,
-                emit_welcome_event=False,
+                emit_welcome_event=True,
                 emit_switch_message=False,
             )
         )
@@ -398,7 +398,7 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             op.ChangeThinkingOperation(
                 session_id=sid,
                 thinking=thinking,
-                emit_welcome_event=False,
+                emit_welcome_event=True,
                 emit_switch_message=False,
             )
         )

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

@@ -7,6 +7,7 @@ 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.modes.repl.clipboard import copy_to_clipboard
 from klaude_code.ui.terminal.selector import SelectItem, select_one
 
 FORK_SELECT_STYLE = Style(
@@ -215,6 +216,9 @@ class ForkSessionCommand(CommandABC):
             new_session = agent.session.fork()
             await new_session.wait_for_flush()
 
+            resume_cmd = f"klaude --resume-by-id {new_session.id}"
+            copy_to_clipboard(resume_cmd)
+
             event = events.DeveloperMessageEvent(
                 session_id=agent.session.id,
                 item=model.DeveloperMessageItem(
@@ -247,6 +251,9 @@ class ForkSessionCommand(CommandABC):
         # Build result message
         fork_description = "entire conversation" if selected is None else f"up to message index {selected}"
 
+        resume_cmd = f"klaude --resume-by-id {new_session.id}"
+        copy_to_clipboard(resume_cmd)
+
         event = events.DeveloperMessageEvent(
             session_id=agent.session.id,
             item=model.DeveloperMessageItem(

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
@@ -87,6 +87,30 @@ provider_list:
         input: 1.75
         output: 14.0
         cache_read: 0.17
+  - model_name: gpt-5.2-medium
+    model_params:
+      model: openai/gpt-5.2
+      max_tokens: 128000
+      context_limit: 400000
+      verbosity: high
+      thinking:
+        reasoning_effort: medium
+      cost:
+        input: 1.75
+        output: 14.0
+        cache_read: 0.17
+  - model_name: gpt-5.2-low
+    model_params:
+      model: openai/gpt-5.2
+      max_tokens: 128000
+      context_limit: 400000
+      verbosity: low
+      thinking:
+        reasoning_effort: low
+      cost:
+        input: 1.75
+        output: 14.0
+        cache_read: 0.17
   - model_name: gpt-5.2-fast
     model_params:
       model: openai/gpt-5.2
@@ -194,6 +218,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
 
 
@@ -243,6 +257,11 @@ def get_example_config() -> UserConfig:
                             model="model-id-from-provider",
                             max_tokens=16000,
                             context_limit=200000,
+                            cost=llm_param.Cost(
+                                input=1,
+                                output=10,
+                                cache_read=0.1,
+                            ),
                         ),
                     ),
                 ],

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
 
 

klaude_code/const.py

@@ -4,8 +4,21 @@ This module consolidates all magic numbers and configuration values
 that were previously scattered across the codebase.
 """
 
+import os
 from pathlib import Path
 
+
+def _get_int_env(name: str, default: int) -> int:
+    """Get an integer value from environment variable, or return default."""
+    val = os.environ.get(name)
+    if val is None:
+        return default
+    try:
+        return int(val)
+    except ValueError:
+        return default
+
+
 # =============================================================================
 # Agent Configuration
 # =============================================================================
@@ -47,10 +60,12 @@ TODO_REMINDER_TOOL_CALL_THRESHOLD = 10
 READ_CHAR_LIMIT_PER_LINE = 2000
 
 # Maximum number of lines to read from a file
-READ_GLOBAL_LINE_CAP = 2000
+# Can be overridden via KLAUDE_READ_GLOBAL_LINE_CAP environment variable
+READ_GLOBAL_LINE_CAP = _get_int_env("KLAUDE_READ_GLOBAL_LINE_CAP", 2000)
 
 # Maximum total characters to read (truncates beyond this limit)
-READ_MAX_CHARS = 50000
+# Can be overridden via KLAUDE_READ_MAX_CHARS environment variable
+READ_MAX_CHARS = _get_int_env("KLAUDE_READ_MAX_CHARS", 50000)
 
 # Maximum image file size in bytes (4MB)
 READ_MAX_IMAGE_BYTES = 4 * 1024 * 1024

klaude_code/core/executor.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 import asyncio
 import subprocess
+import sys
 from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
@@ -427,14 +428,26 @@ class ExecutorContext:
         return build_export_html(agent.session, system_prompt, tool_schemas, model_name)
 
     def _open_file(self, path: Path) -> None:
+        # Select platform-appropriate command
+        if sys.platform == "darwin":
+            cmd = "open"
+        elif sys.platform == "win32":
+            cmd = "start"
+        else:
+            cmd = "xdg-open"
+
         try:
             # Detach stdin to prevent interference with prompt_toolkit's terminal state
-            subprocess.run(["open", str(path)], stdin=subprocess.DEVNULL, check=True)
+            if sys.platform == "win32":
+                # Windows 'start' requires shell=True
+                subprocess.run(f'start "" "{path}"', shell=True, stdin=subprocess.DEVNULL, check=True)
+            else:
+                subprocess.run([cmd, str(path)], stdin=subprocess.DEVNULL, check=True)
         except FileNotFoundError as exc:  # pragma: no cover
-            msg = "`open` command not found; please open the HTML manually."
+            msg = f"`{cmd}` command not found; please open the HTML manually."
             raise RuntimeError(msg) from exc
         except subprocess.CalledProcessError as exc:  # pragma: no cover
-            msg = f"Failed to open HTML with `open`: {exc}"
+            msg = f"Failed to open HTML with `{cmd}`: {exc}"
             raise RuntimeError(msg) from exc
 
     async def handle_interrupt(self, operation: op.InterruptOperation) -> None:

klaude_code/core/task.py

@@ -220,7 +220,9 @@ class TaskExecutor:
                         error_msg = f"Retrying {attempt + 1}/{const.MAX_FAILED_TURN_RETRIES} in {delay:.1f}s"
                         if last_error_message:
                             error_msg = f"{error_msg} - {last_error_message}"
-                        yield events.ErrorEvent(error_message=error_msg, can_retry=True)
+                        yield events.ErrorEvent(
+                            error_message=error_msg, can_retry=True, session_id=session_ctx.session_id
+                        )
                         await asyncio.sleep(delay)
                 finally:
                     self._current_turn = None
@@ -234,7 +236,7 @@ class TaskExecutor:
                 final_error = f"Turn failed after {const.MAX_FAILED_TURN_RETRIES} retries."
                 if last_error_message:
                     final_error = f"{last_error_message}\n{final_error}"
-                yield events.ErrorEvent(error_message=final_error, can_retry=False)
+                yield events.ErrorEvent(error_message=final_error, can_retry=False, session_id=session_ctx.session_id)
                 return
 
             if turn is None or turn.task_finished:
@@ -244,7 +246,7 @@ class TaskExecutor:
                         error_msg = "Sub-agent returned empty result, retrying..."
                     else:
                         error_msg = "Agent returned empty result, retrying..."
-                    yield events.ErrorEvent(error_message=error_msg, can_retry=True)
+                    yield events.ErrorEvent(error_message=error_msg, can_retry=True, session_id=session_ctx.session_id)
                     continue
                 break
 

klaude_code/core/tool/shell/command_safety.py

@@ -275,12 +275,10 @@ def _is_safe_argv(argv: list[str]) -> SafetyCheckResult:
             "tag",
             "clone",
             "worktree",
+            "push",
+            "pull",
+            "remote",
         }
-        # Block remote operations
-        blocked_git_cmds = {"push", "pull", "remote"}
-
-        if sub in blocked_git_cmds:
-            return SafetyCheckResult(False, f"git: Remote operation '{sub}' not allowed")
         if sub not in allowed_git_cmds:
             return SafetyCheckResult(False, f"git: Subcommand '{sub}' not in allow list")
         return SafetyCheckResult(True)