klaude-code 1.2.26__py3-none-any.whl → 1.2.28__py3-none-any.whl

klaude_code/command/__init__.py

@@ -31,6 +31,7 @@ def ensure_commands_loaded() -> None:
     from .debug_cmd import DebugCommand
     from .export_cmd import ExportCommand
     from .export_online_cmd import ExportOnlineCommand
+    from .fork_session_cmd import ForkSessionCommand
     from .help_cmd import HelpCommand
     from .model_cmd import ModelCommand
     from .refresh_cmd import RefreshTerminalCommand
@@ -45,6 +46,7 @@ def ensure_commands_loaded() -> None:
     register(RefreshTerminalCommand())
     register(ThinkingCommand())
     register(ModelCommand())
+    register(ForkSessionCommand())
     load_prompt_commands()
     register(StatusCommand())
     register(HelpCommand())
@@ -63,6 +65,7 @@ def __getattr__(name: str) -> object:
         "DebugCommand": "debug_cmd",
         "ExportCommand": "export_cmd",
         "ExportOnlineCommand": "export_online_cmd",
+        "ForkSessionCommand": "fork_session_cmd",
         "HelpCommand": "help_cmd",
         "ModelCommand": "model_cmd",
         "RefreshTerminalCommand": "refresh_cmd",

klaude_code/command/export_online_cmd.py

@@ -47,20 +47,23 @@ class ExportOnlineCommand(CommandABC):
             )
             return CommandResult(events=[event])
 
-        # Check if user is logged in to surge
-        if not self._is_surge_logged_in(surge_cmd):
-            login_cmd = " ".join([*surge_cmd, "login"])
-            event = events.DeveloperMessageEvent(
-                session_id=agent.session.id,
-                item=model.DeveloperMessageItem(
-                    content=f"Not logged in to surge.sh. Please run: {login_cmd}",
-                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
-                ),
-            )
-            return CommandResult(events=[event])
-
         try:
             console = Console()
+            # Check login status inside status context since npx surge whoami can be slow
+            with console.status(Text("Checking surge.sh login status...", style="dim"), spinner_style="dim"):
+                logged_in = self._is_surge_logged_in(surge_cmd)
+
+            if not logged_in:
+                login_cmd = " ".join([*surge_cmd, "login"])
+                event = events.DeveloperMessageEvent(
+                    session_id=agent.session.id,
+                    item=model.DeveloperMessageItem(
+                        content=f"Not logged in to surge.sh. Please run: {login_cmd}",
+                        command_output=model.CommandOutput(command_name=self.name, is_error=True),
+                    ),
+                )
+                return CommandResult(events=[event])
+
             with console.status(Text("Deploying to surge.sh...", style="dim"), spinner_style="dim"):
                 html_doc = self._build_html(agent)
                 domain = self._generate_domain()

klaude_code/command/fork_session_cmd.py

@@ -0,0 +1,42 @@
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
+from klaude_code.protocol import commands, events, model
+
+
+class ForkSessionCommand(CommandABC):
+    """Fork current session to a new session id and show a resume command."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.FORK_SESSION
+
+    @property
+    def summary(self) -> str:
+        return "Fork the current session and show a resume-by-id command"
+
+    async def run(self, agent: Agent, user_input: model.UserInputPayload) -> CommandResult:
+        del user_input  # unused
+
+        if agent.session.messages_count == 0:
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content="(no messages to fork)",
+                    command_output=model.CommandOutput(command_name=self.name),
+                ),
+            )
+            return CommandResult(events=[event])
+
+        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])

klaude_code/config/__init__.py

@@ -1,7 +1,9 @@
-from .config import Config, config_path, load_config
+from .config import Config, UserConfig, config_path, load_config, print_no_available_models_hint
 
 __all__ = [
     "Config",
+    "UserConfig",
     "config_path",
     "load_config",
+    "print_no_available_models_hint",
 ]

klaude_code/config/assets/__init__.py

@@ -0,0 +1 @@
+# Asset files for config module

klaude_code/config/assets/builtin_config.yaml

@@ -0,0 +1,233 @@
+# Built-in provider and model configurations
+# Users can start using klaude by simply setting environment variables
+# (ANTHROPIC_API_KEY, OPENAI_API_KEY, etc.) without manual configuration.
+
+provider_list:
+- provider_name: anthropic
+  protocol: anthropic
+  api_key: ${ANTHROPIC_API_KEY}
+  model_list:
+  - model_name: sonnet
+    model_params:
+      model: claude-sonnet-4-5-20250929
+      context_limit: 200000
+      provider_routing:
+        sort: throughput
+      cost:
+        input: 3.0
+        output: 15.0
+        cache_read: 0.3
+        cache_write: 3.75
+  - model_name: opus
+    model_params:
+      model: claude-opus-4-5-20251101
+      context_limit: 200000
+      verbosity: high
+      thinking:
+        type: enabled
+        budget_tokens: 2048
+      cost:
+        input: 5.0
+        output: 25.0
+        cache_read: 0.5
+        cache_write: 6.25
+
+- provider_name: openai
+  protocol: responses
+  api_key: ${OPENAI_API_KEY}
+  model_list:
+  - model_name: gpt-5.2
+    model_params:
+      model: gpt-5.2
+      max_tokens: 128000
+      context_limit: 400000
+      verbosity: high
+      thinking:
+        reasoning_effort: high
+      cost:
+        input: 1.75
+        output: 14.0
+        cache_read: 0.17
+
+- provider_name: openrouter
+  protocol: openrouter
+  api_key: ${OPENROUTER_API_KEY}
+  model_list:
+  - model_name: gpt-5.1-codex-max
+    model_params:
+      model: openai/gpt-5.1-codex-max
+      max_tokens: 128000
+      context_limit: 400000
+      thinking:
+        reasoning_effort: medium
+      cost:
+        input: 1.25
+        output: 10.0
+        cache_read: 0.13
+  - model_name: gpt-5.2
+    model_params:
+      model: openai/gpt-5.2
+      max_tokens: 128000
+      context_limit: 400000
+      verbosity: high
+      thinking:
+        reasoning_effort: high
+      cost:
+        input: 1.75
+        output: 14.0
+        cache_read: 0.17
+  - model_name: gpt-5.2-fast
+    model_params:
+      model: openai/gpt-5.2
+      max_tokens: 128000
+      context_limit: 400000
+      verbosity: low
+      thinking:
+        reasoning_effort: none
+      cost:
+        input: 1.75
+        output: 14.0
+        cache_read: 0.17
+  - model_name: kimi
+    model_params:
+      model: moonshotai/kimi-k2-thinking
+      context_limit: 262144
+      provider_routing:
+        only:
+        - moonshotai/turbo
+      cost:
+        input: 0.6
+        output: 2.5
+        cache_read: 0.15
+  - model_name: haiku
+    model_params:
+      model: anthropic/claude-haiku-4.5
+      context_limit: 200000
+      cost:
+        input: 1.0
+        output: 5.0
+        cache_read: 0.1
+        cache_write: 1.25
+  - model_name: sonnet
+    model_params:
+      model: anthropic/claude-4.5-sonnet
+      context_limit: 200000
+      provider_routing:
+        sort: throughput
+      cost:
+        input: 3.0
+        output: 15.0
+        cache_read: 0.3
+        cache_write: 3.75
+  - model_name: opus
+    model_params:
+      model: anthropic/claude-4.5-opus
+      context_limit: 200000
+      verbosity: high
+      thinking:
+        type: enabled
+        budget_tokens: 2048
+      cost:
+        input: 5.0
+        output: 25.0
+        cache_read: 0.5
+        cache_write: 6.25
+  - model_name: gemini-pro
+    model_params:
+      model: google/gemini-3-pro-preview
+      context_limit: 1048576
+      thinking:
+        reasoning_effort: high
+      cost:
+        input: 2.0
+        output: 12.0
+        cache_read: 0.2
+  - model_name: gemini-flash
+    model_params:
+      model: google/gemini-3-flash-preview
+      context_limit: 1048576
+      thinking:
+        reasoning_effort: medium
+      cost:
+        input: 0.5
+        output: 3.0
+        cache_read: 0.05
+  - model_name: grok
+    model_params:
+      model: x-ai/grok-4.1-fast
+      context_limit: 2000000
+      thinking:
+        type: enabled
+        budget_tokens: 2048
+      cost:
+        input: 0.2
+        output: 0.5
+        cache_read: 0.05
+  - model_name: minimax
+    model_params:
+      model: minimax/minimax-m2.1
+      context_limit: 204800
+      cost:
+        input: 0.3
+        output: 1.2
+        cache_read: 0.03
+  - model_name: glm
+    model_params:
+      model: z-ai/glm-4.7
+      context_limit: 200000
+      provider_routing:
+        only:
+        - z-ai
+      cost:
+        input: 0.44
+        output: 1.74
+        cache_read: 0.04
+
+- provider_name: deepseek
+  protocol: anthropic
+  api_key: ${DEEPSEEK_API_KEY}
+  base_url: https://api.deepseek.com/anthropic
+  model_list:
+  - model_name: deepseek
+    provider: deepseek
+    model_params:
+      model: deepseek-reasoner
+      context_limit: 128000
+      thinking:
+        type: enabled
+        budget_tokens: 2048
+      cost:
+        input: 2
+        output: 3
+        cache_read: 0.2
+        currency: CNY
+
+- provider_name: moonshot
+  protocol: anthropic
+  api_key: ${MOONSHOT_API_KEY}
+  base_url: https://api.moonshot.cn/anthropic
+  model_list:
+  - model_name: kimi@moonshot
+    model_params:
+      model: kimi-k2-thinking
+      context_limit: 262144
+      thinking:
+        type: enabled
+        budget_tokens: 8192
+      cost:
+        input: 4.0
+        output: 16.0
+        cache_read: 1.0
+        currency: CNY
+
+- provider_name: codex
+  protocol: codex
+  model_list:
+  - model_name: gpt-5.2-codex
+    provider: codex
+    model_params:
+      model: gpt-5.2-codex
+      thinking:
+        reasoning_effort: medium
+      context_limit: 400000
+      max_tokens: 128000

klaude_code/config/builtin_config.py

@@ -0,0 +1,37 @@
+"""Built-in provider and model configurations.
+
+These configurations allow users to start using klaude by simply setting
+environment variables (ANTHROPIC_API_KEY, OPENAI_API_KEY, etc.) without
+manually configuring providers.
+"""
+
+from functools import lru_cache
+from importlib import resources
+from typing import TYPE_CHECKING
+
+import yaml
+
+if TYPE_CHECKING:
+    from klaude_code.config.config import ProviderConfig
+
+# All supported API key environment variables
+SUPPORTED_API_KEY_ENVS = [
+    "ANTHROPIC_API_KEY",
+    "OPENAI_API_KEY",
+    "OPENROUTER_API_KEY",
+    "DEEPSEEK_API_KEY",
+    "MOONSHOT_API_KEY",
+]
+
+
+@lru_cache(maxsize=1)
+def get_builtin_provider_configs() -> list["ProviderConfig"]:
+    """Load built-in provider configurations from YAML asset."""
+    # Import here to avoid circular import
+    from klaude_code.config.config import ProviderConfig
+
+    assets = resources.files("klaude_code.config.assets")
+    yaml_content = (assets / "builtin_config.yaml").read_text()
+    data = yaml.safe_load(yaml_content)
+
+    return [ProviderConfig.model_validate(p) for p in data.get("provider_list", [])]