klaude-code 1.6.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/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/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
 
 

klaude_code/llm/anthropic/client.py

@@ -1,7 +1,7 @@
 import json
 import os
 from collections.abc import AsyncGenerator
-from typing import override
+from typing import Any, override
 
 import anthropic
 import httpx
@@ -58,6 +58,130 @@ def build_payload(param: llm_param.LLMCallParameter) -> MessageCreateParamsStrea
     return payload
 
 
+async def parse_anthropic_stream(
+    stream: Any,
+    param: llm_param.LLMCallParameter,
+    metadata_tracker: MetadataTracker,
+) -> AsyncGenerator[model.ConversationItem]:
+    """Parse Anthropic beta messages stream and yield conversation items.
+
+    This function is shared between AnthropicClient and BedrockClient.
+    """
+    accumulated_thinking: list[str] = []
+    accumulated_content: list[str] = []
+    response_id: str | None = None
+
+    current_tool_name: str | None = None
+    current_tool_call_id: str | None = None
+    current_tool_inputs: list[str] | None = None
+
+    input_token = 0
+    cached_token = 0
+
+    async for event in await stream:
+        log_debug(
+            f"[{event.type}]",
+            event.model_dump_json(exclude_none=True),
+            style="blue",
+            debug_type=DebugType.LLM_STREAM,
+        )
+        match event:
+            case BetaRawMessageStartEvent() as event:
+                response_id = event.message.id
+                cached_token = event.message.usage.cache_read_input_tokens or 0
+                input_token = event.message.usage.input_tokens
+                yield model.StartItem(response_id=response_id)
+            case BetaRawContentBlockDeltaEvent() as event:
+                match event.delta:
+                    case BetaThinkingDelta() as delta:
+                        if delta.thinking:
+                            metadata_tracker.record_token()
+                        accumulated_thinking.append(delta.thinking)
+                        yield model.ReasoningTextDelta(
+                            content=delta.thinking,
+                            response_id=response_id,
+                        )
+                    case BetaSignatureDelta() as delta:
+                        yield model.ReasoningEncryptedItem(
+                            encrypted_content=delta.signature,
+                            response_id=response_id,
+                            model=str(param.model),
+                        )
+                    case BetaTextDelta() as delta:
+                        if delta.text:
+                            metadata_tracker.record_token()
+                        accumulated_content.append(delta.text)
+                        yield model.AssistantMessageDelta(
+                            content=delta.text,
+                            response_id=response_id,
+                        )
+                    case BetaInputJSONDelta() as delta:
+                        if current_tool_inputs is not None:
+                            if delta.partial_json:
+                                metadata_tracker.record_token()
+                            current_tool_inputs.append(delta.partial_json)
+                    case _:
+                        pass
+            case BetaRawContentBlockStartEvent() as event:
+                match event.content_block:
+                    case BetaToolUseBlock() as block:
+                        metadata_tracker.record_token()
+                        yield model.ToolCallStartItem(
+                            response_id=response_id,
+                            call_id=block.id,
+                            name=block.name,
+                        )
+                        current_tool_name = block.name
+                        current_tool_call_id = block.id
+                        current_tool_inputs = []
+                    case _:
+                        pass
+            case BetaRawContentBlockStopEvent():
+                if len(accumulated_thinking) > 0:
+                    metadata_tracker.record_token()
+                    full_thinking = "".join(accumulated_thinking)
+                    yield model.ReasoningTextItem(
+                        content=full_thinking,
+                        response_id=response_id,
+                        model=str(param.model),
+                    )
+                    accumulated_thinking.clear()
+                if len(accumulated_content) > 0:
+                    metadata_tracker.record_token()
+                    yield model.AssistantMessageItem(
+                        content="".join(accumulated_content),
+                        response_id=response_id,
+                    )
+                    accumulated_content.clear()
+                if current_tool_name and current_tool_call_id:
+                    metadata_tracker.record_token()
+                    yield model.ToolCallItem(
+                        name=current_tool_name,
+                        call_id=current_tool_call_id,
+                        arguments="".join(current_tool_inputs) if current_tool_inputs else "",
+                        response_id=response_id,
+                    )
+                    current_tool_name = None
+                    current_tool_call_id = None
+                    current_tool_inputs = None
+            case BetaRawMessageDeltaEvent() as event:
+                metadata_tracker.set_usage(
+                    model.Usage(
+                        input_tokens=input_token + cached_token,
+                        output_tokens=event.usage.output_tokens,
+                        cached_tokens=cached_token,
+                        context_size=input_token + cached_token + event.usage.output_tokens,
+                        context_limit=param.context_limit,
+                        max_tokens=param.max_tokens,
+                    )
+                )
+                metadata_tracker.set_model_name(str(param.model))
+                metadata_tracker.set_response_id(response_id)
+                yield metadata_tracker.finalize()
+            case _:
+                pass
+
+
 @register(llm_param.LLMClientProtocol.ANTHROPIC)
 class AnthropicClient(LLMClientABC):
     def __init__(self, config: llm_param.LLMConfigParameter):
@@ -102,119 +226,8 @@ class AnthropicClient(LLMClientABC):
             extra_headers={"extra": json.dumps({"session_id": param.session_id}, sort_keys=True)},
         )
 
-        accumulated_thinking: list[str] = []
-        accumulated_content: list[str] = []
-        response_id: str | None = None
-
-        current_tool_name: str | None = None
-        current_tool_call_id: str | None = None
-        current_tool_inputs: list[str] | None = None
-
-        input_token = 0
-        cached_token = 0
-
         try:
-            async for event in await stream:
-                log_debug(
-                    f"[{event.type}]",
-                    event.model_dump_json(exclude_none=True),
-                    style="blue",
-                    debug_type=DebugType.LLM_STREAM,
-                )
-                match event:
-                    case BetaRawMessageStartEvent() as event:
-                        response_id = event.message.id
-                        cached_token = event.message.usage.cache_read_input_tokens or 0
-                        input_token = event.message.usage.input_tokens
-                        yield model.StartItem(response_id=response_id)
-                    case BetaRawContentBlockDeltaEvent() as event:
-                        match event.delta:
-                            case BetaThinkingDelta() as delta:
-                                if delta.thinking:
-                                    metadata_tracker.record_token()
-                                accumulated_thinking.append(delta.thinking)
-                                yield model.ReasoningTextDelta(
-                                    content=delta.thinking,
-                                    response_id=response_id,
-                                )
-                            case BetaSignatureDelta() as delta:
-                                yield model.ReasoningEncryptedItem(
-                                    encrypted_content=delta.signature,
-                                    response_id=response_id,
-                                    model=str(param.model),
-                                )
-                            case BetaTextDelta() as delta:
-                                if delta.text:
-                                    metadata_tracker.record_token()
-                                accumulated_content.append(delta.text)
-                                yield model.AssistantMessageDelta(
-                                    content=delta.text,
-                                    response_id=response_id,
-                                )
-                            case BetaInputJSONDelta() as delta:
-                                if current_tool_inputs is not None:
-                                    if delta.partial_json:
-                                        metadata_tracker.record_token()
-                                    current_tool_inputs.append(delta.partial_json)
-                            case _:
-                                pass
-                    case BetaRawContentBlockStartEvent() as event:
-                        match event.content_block:
-                            case BetaToolUseBlock() as block:
-                                metadata_tracker.record_token()
-                                yield model.ToolCallStartItem(
-                                    response_id=response_id,
-                                    call_id=block.id,
-                                    name=block.name,
-                                )
-                                current_tool_name = block.name
-                                current_tool_call_id = block.id
-                                current_tool_inputs = []
-                            case _:
-                                pass
-                    case BetaRawContentBlockStopEvent() as event:
-                        if len(accumulated_thinking) > 0:
-                            metadata_tracker.record_token()
-                            full_thinking = "".join(accumulated_thinking)
-                            yield model.ReasoningTextItem(
-                                content=full_thinking,
-                                response_id=response_id,
-                                model=str(param.model),
-                            )
-                            accumulated_thinking.clear()
-                        if len(accumulated_content) > 0:
-                            metadata_tracker.record_token()
-                            yield model.AssistantMessageItem(
-                                content="".join(accumulated_content),
-                                response_id=response_id,
-                            )
-                            accumulated_content.clear()
-                        if current_tool_name and current_tool_call_id:
-                            metadata_tracker.record_token()
-                            yield model.ToolCallItem(
-                                name=current_tool_name,
-                                call_id=current_tool_call_id,
-                                arguments="".join(current_tool_inputs) if current_tool_inputs else "",
-                                response_id=response_id,
-                            )
-                            current_tool_name = None
-                            current_tool_call_id = None
-                            current_tool_inputs = None
-                    case BetaRawMessageDeltaEvent() as event:
-                        metadata_tracker.set_usage(
-                            model.Usage(
-                                input_tokens=input_token + cached_token,
-                                output_tokens=event.usage.output_tokens,
-                                cached_tokens=cached_token,
-                                context_size=input_token + cached_token + event.usage.output_tokens,
-                                context_limit=param.context_limit,
-                                max_tokens=param.max_tokens,
-                            )
-                        )
-                        metadata_tracker.set_model_name(str(param.model))
-                        metadata_tracker.set_response_id(response_id)
-                        yield metadata_tracker.finalize()
-                    case _:
-                        pass
+            async for item in parse_anthropic_stream(stream, param, metadata_tracker):
+                yield item
         except (APIError, httpx.HTTPError) as e:
             yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")

klaude_code/llm/bedrock/__init__.py

@@ -0,0 +1,3 @@
+from klaude_code.llm.bedrock.client import BedrockClient
+
+__all__ = ["BedrockClient"]

klaude_code/llm/bedrock/client.py

@@ -0,0 +1,60 @@
+"""AWS Bedrock LLM client using Anthropic SDK."""
+
+import json
+from collections.abc import AsyncGenerator
+from typing import override
+
+import anthropic
+import httpx
+from anthropic import APIError
+
+from klaude_code.llm.anthropic.client import build_payload, parse_anthropic_stream
+from klaude_code.llm.client import LLMClientABC
+from klaude_code.llm.input_common import apply_config_defaults
+from klaude_code.llm.registry import register
+from klaude_code.llm.usage import MetadataTracker
+from klaude_code.protocol import llm_param, model
+from klaude_code.trace import DebugType, log_debug
+
+
+@register(llm_param.LLMClientProtocol.BEDROCK)
+class BedrockClient(LLMClientABC):
+    """LLM client for AWS Bedrock using Anthropic SDK."""
+
+    def __init__(self, config: llm_param.LLMConfigParameter):
+        super().__init__(config)
+        self.client = anthropic.AsyncAnthropicBedrock(
+            aws_access_key=config.aws_access_key,
+            aws_secret_key=config.aws_secret_key,
+            aws_region=config.aws_region,
+            aws_session_token=config.aws_session_token,
+            aws_profile=config.aws_profile,
+            timeout=httpx.Timeout(300.0, connect=15.0, read=285.0),
+        )
+
+    @classmethod
+    @override
+    def create(cls, config: llm_param.LLMConfigParameter) -> "LLMClientABC":
+        return cls(config)
+
+    @override
+    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem]:
+        param = apply_config_defaults(param, self.get_llm_config())
+
+        metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
+
+        payload = build_payload(param)
+
+        log_debug(
+            json.dumps(payload, ensure_ascii=False, default=str),
+            style="yellow",
+            debug_type=DebugType.LLM_PAYLOAD,
+        )
+
+        stream = self.client.beta.messages.create(**payload)
+
+        try:
+            async for item in parse_anthropic_stream(stream, param, metadata_tracker):
+                yield item
+        except (APIError, httpx.HTTPError) as e:
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")

klaude_code/llm/google/__init__.py

@@ -0,0 +1,3 @@
+from .client import GoogleClient
+
+__all__ = ["GoogleClient"]

klaude_code/llm/google/client.py

@@ -0,0 +1,309 @@
+# pyright: reportUnknownMemberType=false
+# pyright: reportUnknownVariableType=false
+# pyright: reportUnknownArgumentType=false
+# pyright: reportAttributeAccessIssue=false
+
+import json
+from collections.abc import AsyncGenerator, AsyncIterator
+from typing import Any, cast, override
+from uuid import uuid4
+
+import httpx
+from google.genai import Client
+from google.genai.errors import APIError, ClientError, ServerError
+from google.genai.types import (
+    FunctionCallingConfig,
+    FunctionCallingConfigMode,
+    GenerateContentConfig,
+    HttpOptions,
+    ThinkingConfig,
+    ToolConfig,
+    UsageMetadata,
+)
+
+from klaude_code.llm.client import LLMClientABC
+from klaude_code.llm.google.input import convert_history_to_contents, convert_tool_schema
+from klaude_code.llm.input_common import apply_config_defaults
+from klaude_code.llm.registry import register
+from klaude_code.llm.usage import MetadataTracker
+from klaude_code.protocol import llm_param, model
+from klaude_code.trace import DebugType, log_debug
+
+
+def _build_config(param: llm_param.LLMCallParameter) -> GenerateContentConfig:
+    tool_list = convert_tool_schema(param.tools)
+    tool_config: ToolConfig | None = None
+
+    if tool_list:
+        tool_config = ToolConfig(
+            function_calling_config=FunctionCallingConfig(
+                mode=FunctionCallingConfigMode.AUTO,
+                # Gemini streams tool args; keep this enabled to maximize fidelity.
+                stream_function_call_arguments=True,
+            )
+        )
+
+    thinking_config: ThinkingConfig | None = None
+    if param.thinking and param.thinking.type == "enabled":
+        thinking_config = ThinkingConfig(
+            include_thoughts=True,
+            thinking_budget=param.thinking.budget_tokens,
+        )
+
+    return GenerateContentConfig(
+        system_instruction=param.system,
+        temperature=param.temperature,
+        max_output_tokens=param.max_tokens,
+        tools=tool_list or None,
+        tool_config=tool_config,
+        thinking_config=thinking_config,
+    )
+
+
+def _usage_from_metadata(
+    usage: UsageMetadata | None,
+    *,
+    context_limit: int | None,
+    max_tokens: int | None,
+) -> model.Usage | None:
+    if usage is None:
+        return None
+
+    cached = usage.cached_content_token_count or 0
+    prompt = usage.prompt_token_count or 0
+    response = usage.response_token_count or 0
+    thoughts = usage.thoughts_token_count or 0
+
+    total = usage.total_token_count
+    if total is None:
+        total = prompt + cached + response + thoughts
+
+    return model.Usage(
+        input_tokens=prompt + cached,
+        cached_tokens=cached,
+        output_tokens=response + thoughts,
+        reasoning_tokens=thoughts,
+        context_size=total,
+        context_limit=context_limit,
+        max_tokens=max_tokens,
+    )
+
+
+def _partial_arg_value(partial: Any) -> Any:
+    if getattr(partial, "string_value", None) is not None:
+        return partial.string_value
+    if getattr(partial, "number_value", None) is not None:
+        return partial.number_value
+    if getattr(partial, "bool_value", None) is not None:
+        return partial.bool_value
+    if getattr(partial, "null_value", None) is not None:
+        return None
+    return None
+
+
+def _merge_partial_args(dst: dict[str, Any], partial_args: list[Any] | None) -> None:
+    if not partial_args:
+        return
+    for partial in partial_args:
+        json_path = getattr(partial, "json_path", None)
+        if not isinstance(json_path, str) or not json_path.startswith("$."):
+            continue
+        key = json_path[2:]
+        if not key or any(ch in key for ch in "[]"):
+            continue
+        dst[key] = _partial_arg_value(partial)
+
+
+async def parse_google_stream(
+    stream: AsyncIterator[Any],
+    param: llm_param.LLMCallParameter,
+    metadata_tracker: MetadataTracker,
+) -> AsyncGenerator[model.ConversationItem]:
+    response_id: str | None = None
+    started = False
+
+    accumulated_text: list[str] = []
+    accumulated_thoughts: list[str] = []
+    thought_signature: str | None = None
+
+    # Track tool calls where args arrive as partial updates.
+    partial_args_by_call: dict[str, dict[str, Any]] = {}
+    started_tool_calls: dict[str, str] = {}  # call_id -> name
+    started_tool_items: set[str] = set()
+    emitted_tool_items: set[str] = set()
+
+    last_usage_metadata: UsageMetadata | None = None
+
+    async for chunk in stream:
+        log_debug(
+            chunk.model_dump_json(exclude_none=True),
+            style="blue",
+            debug_type=DebugType.LLM_STREAM,
+        )
+
+        if response_id is None:
+            response_id = getattr(chunk, "response_id", None) or uuid4().hex
+        assert response_id is not None
+        if not started:
+            started = True
+            yield model.StartItem(response_id=response_id)
+
+        if getattr(chunk, "usage_metadata", None) is not None:
+            last_usage_metadata = chunk.usage_metadata
+
+        candidates = getattr(chunk, "candidates", None) or []
+        candidate0 = candidates[0] if candidates else None
+        content = getattr(candidate0, "content", None) if candidate0 else None
+        parts = getattr(content, "parts", None) if content else None
+        if not parts:
+            continue
+
+        for part in parts:
+            if getattr(part, "text", None) is not None:
+                metadata_tracker.record_token()
+                text = part.text
+                if getattr(part, "thought", False) is True:
+                    accumulated_thoughts.append(text)
+                    if getattr(part, "thought_signature", None):
+                        thought_signature = part.thought_signature
+                    yield model.ReasoningTextDelta(content=text, response_id=response_id)
+                else:
+                    accumulated_text.append(text)
+                    yield model.AssistantMessageDelta(content=text, response_id=response_id)
+
+            function_call = getattr(part, "function_call", None)
+            if function_call is None:
+                continue
+
+            metadata_tracker.record_token()
+            call_id = getattr(function_call, "id", None) or uuid4().hex
+            name = getattr(function_call, "name", None) or ""
+            started_tool_calls.setdefault(call_id, name)
+
+            if call_id not in started_tool_items:
+                started_tool_items.add(call_id)
+                yield model.ToolCallStartItem(response_id=response_id, call_id=call_id, name=name)
+
+            args_obj = getattr(function_call, "args", None)
+            if args_obj is not None:
+                emitted_tool_items.add(call_id)
+                yield model.ToolCallItem(
+                    response_id=response_id,
+                    call_id=call_id,
+                    name=name,
+                    arguments=json.dumps(args_obj, ensure_ascii=False),
+                )
+                continue
+
+            partial_args = getattr(function_call, "partial_args", None)
+            if partial_args is not None:
+                acc = partial_args_by_call.setdefault(call_id, {})
+                _merge_partial_args(acc, partial_args)
+
+            will_continue = getattr(function_call, "will_continue", None)
+            if will_continue is False and call_id in partial_args_by_call and call_id not in emitted_tool_items:
+                emitted_tool_items.add(call_id)
+                yield model.ToolCallItem(
+                    response_id=response_id,
+                    call_id=call_id,
+                    name=name,
+                    arguments=json.dumps(partial_args_by_call[call_id], ensure_ascii=False),
+                )
+
+    # Flush any pending tool calls that never produced args.
+    for call_id, name in started_tool_calls.items():
+        if call_id in emitted_tool_items:
+            continue
+        args = partial_args_by_call.get(call_id, {})
+        emitted_tool_items.add(call_id)
+        yield model.ToolCallItem(
+            response_id=response_id,
+            call_id=call_id,
+            name=name,
+            arguments=json.dumps(args, ensure_ascii=False),
+        )
+
+    if accumulated_thoughts:
+        metadata_tracker.record_token()
+        yield model.ReasoningTextItem(
+            content="".join(accumulated_thoughts),
+            response_id=response_id,
+            model=str(param.model),
+        )
+        if thought_signature:
+            yield model.ReasoningEncryptedItem(
+                encrypted_content=thought_signature,
+                response_id=response_id,
+                model=str(param.model),
+                format="google_thought_signature",
+            )
+
+    if accumulated_text:
+        metadata_tracker.record_token()
+        yield model.AssistantMessageItem(content="".join(accumulated_text), response_id=response_id)
+
+    usage = _usage_from_metadata(last_usage_metadata, context_limit=param.context_limit, max_tokens=param.max_tokens)
+    if usage is not None:
+        metadata_tracker.set_usage(usage)
+    metadata_tracker.set_model_name(str(param.model))
+    metadata_tracker.set_response_id(response_id)
+    yield metadata_tracker.finalize()
+
+
+@register(llm_param.LLMClientProtocol.GOOGLE)
+class GoogleClient(LLMClientABC):
+    def __init__(self, config: llm_param.LLMConfigParameter):
+        super().__init__(config)
+        http_options: HttpOptions | None = None
+        if config.base_url:
+            # If base_url already contains version path, don't append api_version.
+            http_options = HttpOptions(base_url=str(config.base_url), api_version="")
+
+        self.client = Client(
+            api_key=config.api_key,
+            http_options=http_options,
+        )
+
+    @classmethod
+    @override
+    def create(cls, config: llm_param.LLMConfigParameter) -> "LLMClientABC":
+        return cls(config)
+
+    @override
+    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem]:
+        param = apply_config_defaults(param, self.get_llm_config())
+        metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
+
+        contents = convert_history_to_contents(param.input, model_name=str(param.model))
+        config = _build_config(param)
+
+        log_debug(
+            json.dumps(
+                {
+                    "model": str(param.model),
+                    "contents": [c.model_dump(exclude_none=True) for c in contents],
+                    "config": config.model_dump(exclude_none=True),
+                },
+                ensure_ascii=False,
+            ),
+            style="yellow",
+            debug_type=DebugType.LLM_PAYLOAD,
+        )
+
+        try:
+            stream = await self.client.aio.models.generate_content_stream(
+                model=str(param.model),
+                contents=cast(Any, contents),
+                config=config,
+            )
+        except (APIError, ClientError, ServerError, httpx.HTTPError) as e:
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
+            yield metadata_tracker.finalize()
+            return
+
+        try:
+            async for item in parse_google_stream(stream, param=param, metadata_tracker=metadata_tracker):
+                yield item
+        except (APIError, ClientError, ServerError, httpx.HTTPError) as e:
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
+            yield metadata_tracker.finalize()

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/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/session.py

@@ -218,7 +218,9 @@ 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]
 
-        history_to_copy = self.conversation_history[:until_index] if until_index is not None else 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)

{klaude_code-1.6.0.dist-info → klaude_code-1.7.0.dist-info}/METADATA

@@ -1,11 +1,12 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.6.0
+Version: 1.7.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0
 Requires-Dist: ddgs>=9.9.3
 Requires-Dist: diff-match-patch>=20241021
+Requires-Dist: google-genai>=1.56.0
 Requires-Dist: markdown-it-py>=4.0.0
 Requires-Dist: openai>=1.102.0
 Requires-Dist: pillow>=12.0.0
@@ -34,6 +35,10 @@ Minimal code agent CLI.
 - **Output truncation**: Large outputs saved to file system with snapshot links
 - **Skills**: Built-in + user + project Agent Skills (with implicit invocation by Skill tool or explicit invocation by typing `$`)
 - **Sessions**: Resumable with `--continue`
+- **Cost tracking**: Automatic API cost calculation and display (USD/CNY)
+- **Version update check**: Background PyPI version check with upgrade prompts
+- **Terminal title**: Shows current directory and model name
+- **Mermaid diagrams**: Interactive local HTML viewer with zoom, pan, and SVG export
 - **Extras**: Slash commands, sub-agents, image paste, terminal notifications, auto-theming
 
 ## Installation
@@ -77,6 +82,7 @@ klaude [--model <name>] [--select-model]
 - `--select-model`/`-s`: Open the interactive model selector at startup (shows all models unless `--model` is also provided).
 - `--continue`/`-c`: Resume the most recent session.
 - `--resume`/`-r`: Select a session to resume for this project.
+- `--resume-by-id <id>`: Resume a session by its ID directly.
 - `--vanilla`: Minimal mode with only basic tools (Bash, Read, Edit) and no system prompts.
 
 **Model selection behavior:**
@@ -251,12 +257,18 @@ klaude session clean-all
 
 Inside the interactive session (`klaude`), use these commands to streamline your workflow:
 
-- `/dev-doc [feature]` - Generate a comprehensive execution plan for a feature.
-- `/export` - Export last assistant message to a temp Markdown file.
-- `/init` - Bootstrap a new project structure or module.
 - `/model` - Switch the active LLM during the session.
+- `/thinking` - Configure model thinking/reasoning level.
 - `/clear` - Clear the current conversation context.
-- `/diff` - Show local git diff changes.
+- `/status` - Show session usage statistics (cost, tokens, model breakdown).
+- `/resume` - Select and resume a previous session.
+- `/fork-session` - Fork current session to a new session ID (supports interactive fork point selection).
+- `/export` - Export last assistant message to a temp Markdown file.
+- `/export-online` - Export and deploy session to surge.sh as a static webpage.
+- `/debug [filters]` - Toggle debug mode and configure debug filters.
+- `/init` - Bootstrap a new project structure or module.
+- `/dev-doc [feature]` - Generate a comprehensive execution plan for a feature.
+- `/terminal-setup` - Configure terminal for Shift+Enter support.
 - `/help` - List all available commands.
 
 
@@ -267,6 +279,8 @@ Inside the interactive session (`klaude`), use these commands to streamline your
 | `Enter`              | Submit input                                |
 | `Shift+Enter`        | Insert newline (requires `/terminal-setup`) |
 | `Ctrl+J`             | Insert newline                              |
+| `Ctrl+L`             | Open model picker overlay                   |
+| `Ctrl+T`             | Open thinking level picker overlay          |
 | `Ctrl+V`             | Paste image from clipboard                  |
 | `Left/Right`         | Move cursor (wraps across lines)            |
 | `Backspace`          | Delete character or selected text           |
@@ -290,4 +304,18 @@ echo "generate quicksort in python" | klaude exec --model gpt-5.1
 
 # Partial/ambiguous name opens the interactive selector (filtered)
 echo "generate quicksort in python" | klaude exec --model gpt
+
+# Stream all events as JSON lines (for programmatic processing)
+klaude exec "what is 2+2?" --stream-json
 ```
+
+### Sub-Agents
+
+The main agent can spawn specialized sub-agents for specific tasks:
+
+| Sub-Agent | Purpose |
+|-----------|---------|
+| **Explore** | Fast codebase exploration - find files, search code, answer questions about the codebase |
+| **Task** | Handle complex multi-step tasks autonomously |
+| **WebAgent** | Search the web, fetch pages, and analyze content |
+| **Oracle** | Advanced reasoning advisor for code reviews, architecture planning, and bug analysis |

{klaude_code-1.6.0.dist-info → klaude_code-1.7.0.dist-info}/RECORD

@@ -9,11 +9,11 @@ klaude_code/cli/__init__.py,sha256=YzlAoWAr5rx5oe6B_4zPxRFS4QaZauuy1AFwampP5fg,4
 klaude_code/cli/auth_cmd.py,sha256=UWMHjn9xZp2o8OZc-x8y9MnkZgRWOkFXk05iKJYcySE,2561
 klaude_code/cli/config_cmd.py,sha256=hlvslLNgdRHkokq1Pnam0XOdR3jqO3K0vNLqtWnPa6Q,3261
 klaude_code/cli/debug.py,sha256=cPQ7cgATcJTyBIboleW_Q4Pa_t-tGG6x-Hj3woeeuHE,2669
-klaude_code/cli/list_model.py,sha256=uA0PNR1RjUK7BCKu2Q0Sh2xB9j9Gpwp_bsWhroTW6JY,9260
+klaude_code/cli/list_model.py,sha256=3SLURZXH_WgX-vGWIt52NuRm2D14-jcONtiS5GDM2xA,11248
 klaude_code/cli/main.py,sha256=uNZl0RjeLRITbfHerma4_kq2f0hF166dFZqAHLBu580,13236
 klaude_code/cli/runtime.py,sha256=6CtsQa8UcC9ppnNm2AvsF3yxgncyEYwpIIX0bb-3NN0,19826
 klaude_code/cli/self_update.py,sha256=iGuj0i869Zi0M70W52-VVLxZp90ISr30fQpZkHGMK2o,8059
-klaude_code/cli/session_cmd.py,sha256=q2YarlV6KARkFnbm_36ZUvBh8Noj8B7TlMg1RIlt1GE,3154
+klaude_code/cli/session_cmd.py,sha256=9C30dzXCbPobminqenCjYvEuzZBS5zWXg3JpuhxT_OQ,3199
 klaude_code/command/__init__.py,sha256=IK2jz2SFMLVIcVzD5evKk3zWv6u1CjgCgfJXzWdvDlk,3470
 klaude_code/command/clear_cmd.py,sha256=3Ru6pFmOwru06XTLTuEGNUhKgy3COOaNe22Dk0TpGrQ,719
 klaude_code/command/command_abc.py,sha256=wZl_azY6Dpd4OvjtkSEPI3ilXaygLIVkO7NCgNlrofQ,2536
@@ -36,11 +36,11 @@ klaude_code/command/terminal_setup_cmd.py,sha256=SivM1gX_anGY_8DCQNFZ5VblFqt4sVg
 klaude_code/command/thinking_cmd.py,sha256=NPejWmx6HDxoWzAJVLEENCr3Wi6sQSbT8A8LRh1-2Nk,3059
 klaude_code/config/__init__.py,sha256=Qe1BeMekBfO2-Zd30x33lB70hdM1QQZGrp4DbWSQ-II,353
 klaude_code/config/assets/__init__.py,sha256=uMUfmXT3I-gYiI-HVr1DrE60mx5cY1o8V7SYuGqOmvY,32
-klaude_code/config/assets/builtin_config.yaml,sha256=9sfpcVqY3uWVGSdyteH3P_B8ZDwPhfJAoT2Q5o7I1bk,5605
-klaude_code/config/builtin_config.py,sha256=RgbawLV4yKk1IhJsQn04RkitDyLLhCwTqQ3nJkdvHGI,1113
-klaude_code/config/config.py,sha256=rTMU-7IYl_fmthB4LsrCaSgUVttNSw7Agif8XRCmU1g,16331
+klaude_code/config/assets/builtin_config.yaml,sha256=9kQZOEd5PmNZhhQWUnrCENTfHNTBhRIJUfZ444X3rmY,6491
+klaude_code/config/builtin_config.py,sha256=LkHr7Ml-6ir6rObn9hUj5-wa-fgfJsc4T2_NdRa1ax0,1135
+klaude_code/config/config.py,sha256=Nxnwcu8SvOweX6YC6ueVgEEdClLAij1G1v6yyFeiXEc,17114
 klaude_code/config/select_model.py,sha256=PPbQ-BAJkwXPINBcCSPAlZjiXm4rEtg2y0hPnZE8Bnc,5183
-klaude_code/config/thinking.py,sha256=lYkwa4OvJuFk8viY0pgb6I4wCMhn2duVwC3ADf9ZFF0,8712
+klaude_code/config/thinking.py,sha256=X-vywa36ggO_2z4iVhss1mAVEPAwAbcj1s68F0-B0G4,9223
 klaude_code/const.py,sha256=Xc6UKku2sGQE05mvPNCpBbKK205vJrS9CaNAeKvu1AA,4612
 klaude_code/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 klaude_code/core/agent.py,sha256=bWm-UFX_0-KAy5j_YHH8X8o3MJT4-40Ni2EaDP2SL5k,5819
@@ -107,11 +107,16 @@ klaude_code/core/tool/web/web_search_tool.py,sha256=9-dzzMXOdTA_QsdnwHw251R0VelO
 klaude_code/core/turn.py,sha256=PvtVV5GLAvYYAsl3RJNDnIvX1Yp4Va8whr0TR8x-9PI,12706
 klaude_code/llm/__init__.py,sha256=b4AsqnrMIs0a5qR_ti6rZcHwFzAReTwOW96EqozEoSo,287
 klaude_code/llm/anthropic/__init__.py,sha256=PWETvaeNAAX3ue0ww1uRUIxTJG0RpWiutkn7MlwKxBs,67
-klaude_code/llm/anthropic/client.py,sha256=EYBi2Ak1_DCJmZ-HG8uCz1W-6YRg9fLsCc3fjDIaUJM,10656
+klaude_code/llm/anthropic/client.py,sha256=32MdRXm605OUXWrOy3MHAaFrUBih0gchETwNbjuoLmg,10248
 klaude_code/llm/anthropic/input.py,sha256=nyDX3uFK0GVduSiLlBEgBjAl70e0pgIZSF3PbbbuW78,8585
+klaude_code/llm/bedrock/__init__.py,sha256=UmXPBXMmigAJ7euIh59iivSeUdrYJwum0RYU7okkkPM,86
+klaude_code/llm/bedrock/client.py,sha256=U-vWTEwrwpTKMGNPEINEOHtkCwpLv6n3fBDSF4By0mU,2135
 klaude_code/llm/client.py,sha256=FbFnzLUAKM61goiYNdKi8-D4rBfu_ksaxjJtmJn0w_4,960
 klaude_code/llm/codex/__init__.py,sha256=8vN2j2ezWB_UVpfqQ8ooStsBeLL5SY4SUMXOXdWiMaI,132
 klaude_code/llm/codex/client.py,sha256=0BAOiLAdk2PxBEYuC_TGOs4_h6yfNZr1YWuf1lzkBxM,5329
+klaude_code/llm/google/__init__.py,sha256=tQtf_mh_mC3E4S9XAsnhS2JZXGRnYUsBKF0jpXZTvM0,61
+klaude_code/llm/google/client.py,sha256=VqEkPqypzrTyBU_u3yfnMcBlfhZISQi8tejertqICKs,11383
+klaude_code/llm/google/input.py,sha256=AJkrqtTyP80tE80HK5hMaPsHMJK2oF5F3h25cKeELeQ,7930
 klaude_code/llm/input_common.py,sha256=NxiYlhGRFntiLiKm5sKLCF0xGYW6DwcyvIhj6KAZoeU,8533
 klaude_code/llm/openai_compatible/__init__.py,sha256=ACGpnki7k53mMcCl591aw99pm9jZOZk0ghr7atOfNps,81
 klaude_code/llm/openai_compatible/client.py,sha256=sMzHxaDZ4CRDgwSr1pZPqpG6YbHJA-Zk0cFyC_r-ihA,4396
@@ -122,7 +127,7 @@ klaude_code/llm/openrouter/__init__.py,sha256=_As8lHjwj6vapQhLorZttTpukk5ZiCdhFd
 klaude_code/llm/openrouter/client.py,sha256=zUkH7wkiYUJMGS_8iaVwdhzUnry7WLw4Q1IDQtncmK0,4864
 klaude_code/llm/openrouter/input.py,sha256=aHVJCejkwzWaTM_EBbgmzKWyZfttAws2Y7QDW_NCnZk,5671
 klaude_code/llm/openrouter/reasoning.py,sha256=d6RU6twuGfdf0mXGQoxSNRzFaSa3GJFV8Eve5GzDXfU,4472
-klaude_code/llm/registry.py,sha256=grgHetTd-lSxTXiY689QW_Zd6voaid7qBqSnulpg_fE,1734
+klaude_code/llm/registry.py,sha256=ezfUcPld-j_KbC-DBuFeJpqLYTOL54DvGlfJpAslEL8,2089
 klaude_code/llm/responses/__init__.py,sha256=WsiyvnNiIytaYcaAqNiB8GI-5zcpjjeODPbMlteeFjA,67
 klaude_code/llm/responses/client.py,sha256=XEsVehevQJ0WFbEVxIkI-su7VwIcaeq0P9eSrIRcGug,10184
 klaude_code/llm/responses/input.py,sha256=qr61LmQJdcb_f-ofrAz06WpK_k4PEcI36XsyuZAXbKk,6805
@@ -130,7 +135,7 @@ klaude_code/llm/usage.py,sha256=ohQ6EBsWXZj6B4aJ4lDPqfhXRyd0LUAM1nXEJ_elD7A,4207
 klaude_code/protocol/__init__.py,sha256=aGUgzhYqvhuT3Mk2vj7lrHGriH4h9TSbqV1RsRFAZjQ,194
 klaude_code/protocol/commands.py,sha256=4tFt98CD_KvS9C-XEaHLN-S-QFsbDxQb_kGKnPkQlrk,958
 klaude_code/protocol/events.py,sha256=KUMf1rLNdHQO9cZiQ9Pa1VsKkP1PTMbUkp18bu_jGy8,3935
-klaude_code/protocol/llm_param.py,sha256=cb4ubLq21PIsMOC8WJb0aid12z_sT1b7FsbNJMr-jLg,4255
+klaude_code/protocol/llm_param.py,sha256=O5sn3-KJnhS_0FOxDDvAFJ2Sx7ZYdJ74ugnwu-gHZG8,4538
 klaude_code/protocol/model.py,sha256=zz1DeSkpUWDT-OZBlypaGWA4z78TSeefA-Tj8mJMHp4,14257
 klaude_code/protocol/op.py,sha256=--RllgP6Upacb6cqHd26RSwrvqZg4w6GhcebmV8gKJo,5763
 klaude_code/protocol/op_handler.py,sha256=hSxEVPEkk0vRPRsOyJdEn3sa87c_m17wzFGKjaMqa4o,1929
@@ -144,7 +149,7 @@ klaude_code/session/__init__.py,sha256=4sw81uQvEd3YUOOjamKk1KqGmxeb4Ic9T1Tee5zzt
 klaude_code/session/codec.py,sha256=ummbqT7t6uHHXtaS9lOkyhi1h0YpMk7SNSms8DyGAHU,2015
 klaude_code/session/export.py,sha256=dj-IRUNtXL8uONDj9bsEXcEHKyeHY7lIcXv80yP88h4,31022
 klaude_code/session/selector.py,sha256=FpKpGs06fM-LdV-yVUqEY-FJsFn2OtGK-0paXjsZVTg,2770
-klaude_code/session/session.py,sha256=CUbIBpPgl_m2lr3h5jZNktJG0S5eYGZkL37seWdZ7uw,17318
+klaude_code/session/session.py,sha256=VvGMxu5gwFasLlaT9h5x1gBFpuIfXDZJKC1qNwKU8tQ,17342
 klaude_code/session/store.py,sha256=-e-lInCB3N1nFLlet7bipkmPk1PXmGthuMxv5z3hg5o,6953
 klaude_code/session/templates/export_session.html,sha256=bA27AkcC7DQRoWmcMBeaR8WOx1z76hezEDf0aYH-0HQ,119780
 klaude_code/session/templates/mermaid_viewer.html,sha256=lOkETxlctX1C1WJtS1wFw6KhNQmemxwJZFpXDSjlMOk,27842
@@ -207,7 +212,7 @@ klaude_code/ui/terminal/progress_bar.py,sha256=MDnhPbqCnN4GDgLOlxxOEVZPDwVC_XL2N
 klaude_code/ui/terminal/selector.py,sha256=NblhWxUp0AW2OyepG4DHNy4yKE947Oi0OiqlafvBCEE,22144
 klaude_code/ui/utils/__init__.py,sha256=YEsCLjbCPaPza-UXTPUMTJTrc9BmNBUP5CbFWlshyOQ,15
 klaude_code/ui/utils/common.py,sha256=tqHqwgLtAyP805kwRFyoAL4EgMutcNb3Y-GAXJ4IeuM,2263
-klaude_code-1.6.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-klaude_code-1.6.0.dist-info/entry_points.txt,sha256=kkXIXedaTOtjXPr2rVjRVVXZYlFUcBHELaqmyVlWUFA,92
-klaude_code-1.6.0.dist-info/METADATA,sha256=h5IGANYxmMyc3H-4lRuaTKpumksBz0NEnJBAwbSZMuU,9091
-klaude_code-1.6.0.dist-info/RECORD,,
+klaude_code-1.7.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+klaude_code-1.7.0.dist-info/entry_points.txt,sha256=kkXIXedaTOtjXPr2rVjRVVXZYlFUcBHELaqmyVlWUFA,92
+klaude_code-1.7.0.dist-info/METADATA,sha256=AscMVASGUlpBW2pN_633mhuS6Tz9ExAdGZpC97m_6WM,10675
+klaude_code-1.7.0.dist-info/RECORD,,