klaude-code 1.2.16__py3-none-any.whl → 1.2.18__py3-none-any.whl

klaude_code/command/registry.py

@@ -1,14 +1,12 @@
 from importlib.resources import files
 from typing import TYPE_CHECKING
 
-from klaude_code.command.command_abc import CommandResult, InputAction
+from klaude_code.command.command_abc import Agent, CommandResult, InputAction
 from klaude_code.command.prompt_command import PromptCommand
 from klaude_code.protocol import commands, events, model
 from klaude_code.trace import log_debug
 
 if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
     from .command_abc import CommandABC
 
 _COMMANDS: dict[commands.CommandName | str, "CommandABC"] = {}
@@ -50,7 +48,7 @@ def is_slash_command_name(name: str) -> bool:
     return name in _COMMANDS
 
 
-async def dispatch_command(raw: str, agent: "Agent") -> CommandResult:
+async def dispatch_command(raw: str, agent: Agent) -> CommandResult:
     _ensure_commands_loaded()
     # Detect command name
     if not raw.startswith("/"):

klaude_code/command/release_notes_cmd.py

@@ -1,12 +1,8 @@
 from pathlib import Path
-from typing import TYPE_CHECKING
 
-from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 def _read_changelog() -> str:
     """Read CHANGELOG.md from project root."""
@@ -72,7 +68,7 @@ class ReleaseNotesCommand(CommandABC):
     def summary(self) -> str:
         return "Show the latest release notes"
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         changelog = _read_changelog()
         content = _extract_releases(changelog, count=10)
 

klaude_code/command/status_cmd.py

@@ -1,12 +1,7 @@
-from typing import TYPE_CHECKING
-
-from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model
 from klaude_code.session.session import Session
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 class AggregatedUsage(model.BaseModel):
     """Aggregated usage statistics including per-model breakdown."""
@@ -137,7 +132,7 @@ class StatusCommand(CommandABC):
     def summary(self) -> str:
         return "Show session usage statistics"
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         session = agent.session
         aggregated = accumulate_session_usage(session)
 

klaude_code/command/terminal_setup_cmd.py

@@ -1,14 +1,10 @@
 import os
 import subprocess
 from pathlib import Path
-from typing import TYPE_CHECKING
 
-from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 class TerminalSetupCommand(CommandABC):
     """Setup shift+enter newline functionality in terminal"""
@@ -25,7 +21,7 @@ class TerminalSetupCommand(CommandABC):
     def is_interactive(self) -> bool:
         return False
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         term_program = os.environ.get("TERM_PROGRAM", "").lower()
 
         try:

klaude_code/command/thinking_cmd.py

@@ -1,18 +1,14 @@
 import asyncio
-from typing import TYPE_CHECKING
 
 import questionary
 
-from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, llm_param, model
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
-
 # Thinking level options for different protocols
 RESPONSES_LEVELS = ["minimal", "low", "medium", "high"]
 RESPONSES_GPT51_LEVELS = ["none", "minimal", "low", "medium", "high"]
+RESPONSES_GPT52_LEVELS = ["none", "minimal", "low", "medium", "high", "xhigh"]
 RESPONSES_CODEX_MAX_LEVELS = ["medium", "high", "xhigh"]
 
 ANTHROPIC_LEVELS: list[tuple[str, int | None]] = [
@@ -35,7 +31,14 @@ def _is_gpt51_model(model_name: str | None) -> bool:
     """Check if the model is GPT-5.1."""
     if not model_name:
         return False
-    return model_name.lower() in ["gpt5.1", "openai/gpt-5.1", "gpt-5.1-codex-2025-11-13"]
+    return model_name.lower() in ["gpt-5.1", "openai/gpt-5.1", "gpt-5.1-codex-2025-11-13"]
+
+
+def _is_gpt52_model(model_name: str | None) -> bool:
+    """Check if the model is GPT-5.2."""
+    if not model_name:
+        return False
+    return model_name.lower() in ["gpt-5.2", "openai/gpt-5.2"]
 
 
 def _is_codex_max_model(model_name: str | None) -> bool:
@@ -49,6 +52,8 @@ def _get_levels_for_responses(model_name: str | None) -> list[str]:
     """Get thinking levels for responses protocol."""
     if _is_codex_max_model(model_name):
         return RESPONSES_CODEX_MAX_LEVELS
+    if _is_gpt52_model(model_name):
+        return RESPONSES_GPT52_LEVELS
     if _is_gpt51_model(model_name):
         return RESPONSES_GPT51_LEVELS
     return RESPONSES_LEVELS
@@ -164,7 +169,7 @@ class ThinkingCommand(CommandABC):
     def is_interactive(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         if not agent.profile:
             return self._no_change_result(agent, "No profile configured")
 

klaude_code/config/config.py

@@ -79,8 +79,8 @@ class Config(BaseModel):
 
 def get_example_config() -> Config:
     return Config(
-        main_model="gpt-5.1",
-        sub_agent_models={"explore": "haiku", "oracle": "gpt-5.1-high"},
+        main_model="opus",
+        sub_agent_models={"explore": "haiku", "oracle": "gpt-5.1", "webagent": "haiku", "task": "opus"},
         provider_list=[
             llm_param.LLMConfigProviderParameter(
                 provider_name="openai",
@@ -93,6 +93,11 @@ def get_example_config() -> Config:
                 protocol=llm_param.LLMClientProtocol.OPENROUTER,
                 api_key="your-openrouter-api-key",
             ),
+            llm_param.LLMConfigProviderParameter(
+                provider_name="anthropic",
+                protocol=llm_param.LLMClientProtocol.ANTHROPIC,
+                api_key="your-anthropic-api-key",
+            ),
         ],
         model_list=[
             ModelConfig(
@@ -100,31 +105,25 @@ def get_example_config() -> Config:
                 provider="openai",
                 model_params=llm_param.LLMConfigModelParameter(
                     model="gpt-5.1-2025-11-13",
-                    max_tokens=32000,
                     verbosity="medium",
                     thinking=llm_param.Thinking(
-                        reasoning_effort="medium",
+                        reasoning_effort="high",
                         reasoning_summary="auto",
-                        type="enabled",
-                        budget_tokens=None,
                     ),
-                    context_limit=368000,
+                    context_limit=400000,
                 ),
             ),
             ModelConfig(
-                model_name="gpt-5.1-high",
-                provider="openai",
+                model_name="opus",
+                provider="anthropic",
                 model_params=llm_param.LLMConfigModelParameter(
-                    model="gpt-5.1-2025-11-13",
-                    max_tokens=32000,
-                    verbosity="medium",
+                    model="claude-opus-4-5-20251101",
+                    verbosity="high",
                     thinking=llm_param.Thinking(
-                        reasoning_effort="high",
-                        reasoning_summary="auto",
                         type="enabled",
-                        budget_tokens=None,
+                        budget_tokens=31999,
                     ),
-                    context_limit=368000,
+                    context_limit=200000,
                 ),
             ),
             ModelConfig(
@@ -136,7 +135,7 @@ def get_example_config() -> Config:
                     provider_routing=llm_param.OpenRouterProviderRouting(
                         sort="throughput",
                     ),
-                    context_limit=168000,
+                    context_limit=200000,
                 ),
             ),
         ],

klaude_code/config/select_model.py

@@ -1,35 +1,111 @@
-from klaude_code.config.config import load_config
+from klaude_code.config.config import ModelConfig, load_config
 from klaude_code.trace import log
 
 
+def _normalize_model_key(value: str) -> str:
+    """Normalize a model identifier for loose matching.
+
+    This enables aliases like:
+    - gpt52 -> gpt-5.2
+    - gpt5.2 -> gpt-5.2
+
+    Strategy: case-fold + keep only alphanumeric characters.
+    """
+
+    return "".join(ch for ch in value.casefold() if ch.isalnum())
+
+
 def select_model_from_config(preferred: str | None = None) -> str | None:
     """
     Interactive single-choice model selector.
     for `--select-model`
+
+    If preferred is provided:
+    - Exact match: return immediately
+    - Single partial match (case-insensitive): return immediately
+    - Otherwise: fall through to interactive selection
     """
     config = load_config()
     assert config is not None
-    models = sorted(config.model_list, key=lambda m: m.model_name.lower())
+    models: list[ModelConfig] = sorted(config.model_list, key=lambda m: m.model_name.lower())
 
     if not models:
         raise ValueError("No models configured. Please update your config.yaml")
 
     names: list[str] = [m.model_name for m in models]
 
+    # Try to match preferred model name
+    filtered_models = models
+    if preferred and preferred.strip():
+        preferred = preferred.strip()
+        # Exact match
+        if preferred in names:
+            return preferred
+
+        preferred_lower = preferred.lower()
+        # Case-insensitive exact match (model_name or model_params.model)
+        exact_ci_matches = [
+            m
+            for m in models
+            if preferred_lower == m.model_name.lower() or preferred_lower == (m.model_params.model or "").lower()
+        ]
+        if len(exact_ci_matches) == 1:
+            return exact_ci_matches[0].model_name
+
+        # Normalized matching (e.g. gpt52 == gpt-5.2, gpt52 in gpt-5.2-2025-...)
+        preferred_norm = _normalize_model_key(preferred)
+        normalized_matches: list[ModelConfig] = []
+        if preferred_norm:
+            normalized_matches = [
+                m
+                for m in models
+                if preferred_norm == _normalize_model_key(m.model_name)
+                or preferred_norm == _normalize_model_key(m.model_params.model or "")
+            ]
+            if len(normalized_matches) == 1:
+                return normalized_matches[0].model_name
+
+            if not normalized_matches and len(preferred_norm) >= 4:
+                normalized_matches = [
+                    m
+                    for m in models
+                    if preferred_norm in _normalize_model_key(m.model_name)
+                    or preferred_norm in _normalize_model_key(m.model_params.model or "")
+                ]
+                if len(normalized_matches) == 1:
+                    return normalized_matches[0].model_name
+
+        # Partial match (case-insensitive) on model_name or model_params.model.
+        # If normalized matching found candidates (even if multiple), prefer those as the filter set.
+        matches = normalized_matches or [
+            m
+            for m in models
+            if preferred_lower in m.model_name.lower() or preferred_lower in (m.model_params.model or "").lower()
+        ]
+        if len(matches) == 1:
+            return matches[0].model_name
+        if matches:
+            # Multiple matches: filter the list for interactive selection
+            filtered_models = matches
+        else:
+            # No matches: show all models without filter hint
+            preferred = None
+
     try:
         import questionary
 
         choices: list[questionary.Choice] = []
 
-        max_model_name_length = max(len(m.model_name) for m in models)
-        for m in models:
+        max_model_name_length = max(len(m.model_name) for m in filtered_models)
+        for m in filtered_models:
             star = "★ " if m.model_name == config.main_model else "  "
             title = f"{star}{m.model_name:<{max_model_name_length}}   →  {m.model_params.model or 'N/A'} @ {m.provider}"
             choices.append(questionary.Choice(title=title, value=m.model_name))
 
         try:
+            message = f"Select a model (filtered by '{preferred}'):" if preferred else "Select a model:"
             result = questionary.select(
-                message="Select a model:",
+                message=message,
                 choices=choices,
                 pointer="→",
                 instruction="↑↓ to move • Enter to select",

klaude_code/const/__init__.py

@@ -50,7 +50,7 @@ READ_CHAR_LIMIT_PER_LINE = 2000
 READ_GLOBAL_LINE_CAP = 2000
 
 # Maximum total characters to read
-READ_MAX_CHARS = 60000
+READ_MAX_CHARS = 50000
 
 # Maximum file size in KB for text files
 READ_MAX_KB = 256