klaude-code 1.8.0__py3-none-any.whl → 1.9.0__py3-none-any.whl

klaude_code/config/config.py

@@ -81,14 +81,23 @@ class ProviderConfig(llm_param.LLMConfigProviderParameter):
         """
         from klaude_code.protocol.llm_param import LLMClientProtocol
 
-        if self.protocol == LLMClientProtocol.CODEX:
+        if self.protocol == LLMClientProtocol.CODEX_OAUTH:
             # Codex uses OAuth authentication, not API key
             from klaude_code.auth.codex.token_manager import CodexTokenManager
 
             token_manager = CodexTokenManager()
             state = token_manager.get_state()
-            # Consider available if logged in and token not expired
-            return state is None or state.is_expired()
+            # Consider available if logged in. Token refresh happens on-demand.
+            return state is None
+
+        if self.protocol == LLMClientProtocol.CLAUDE_OAUTH:
+            # Claude uses OAuth authentication, not API key
+            from klaude_code.auth.claude.token_manager import ClaudeTokenManager
+
+            token_manager = ClaudeTokenManager()
+            state = token_manager.get_state()
+            # Consider available if logged in. Token refresh happens on-demand.
+            return state is None
 
         if self.protocol == LLMClientProtocol.BEDROCK:
             # Bedrock uses AWS credentials, not API key. Region is always required.
@@ -182,7 +191,17 @@ class Config(BaseModel):
         for provider in self.provider_list:
             # Resolve ${ENV_VAR} syntax for api_key
             api_key = provider.get_resolved_api_key()
-            if not api_key:
+
+            # Some protocols do not use API keys for authentication.
+            if (
+                provider.protocol
+                not in {
+                    llm_param.LLMClientProtocol.CODEX_OAUTH,
+                    llm_param.LLMClientProtocol.CLAUDE_OAUTH,
+                    llm_param.LLMClientProtocol.BEDROCK,
+                }
+                and not api_key
+            ):
                 continue
             for model in provider.model_list:
                 if model.model_name == model_name:
@@ -243,7 +262,7 @@ def get_example_config() -> UserConfig:
     """Generate example config for user reference (will be commented out)."""
     return UserConfig(
         main_model="opus",
-        sub_agent_models={"explore": "haiku", "oracle": "gpt-5.2", "webagent": "sonnet", "task": "sonnet"},
+        sub_agent_models={"explore": "haiku", "webagent": "sonnet", "task": "sonnet"},
         provider_list=[
             UserProviderConfig(
                 provider_name="my-provider",

klaude_code/config/thinking.py

@@ -91,12 +91,12 @@ def format_current_thinking(config: llm_param.LLMConfigParameter) -> str:
 
     protocol = config.protocol
 
-    if protocol in (llm_param.LLMClientProtocol.RESPONSES, llm_param.LLMClientProtocol.CODEX):
+    if protocol in (llm_param.LLMClientProtocol.RESPONSES, llm_param.LLMClientProtocol.CODEX_OAUTH):
         if thinking.reasoning_effort:
             return f"reasoning_effort={thinking.reasoning_effort}"
         return "not set"
 
-    if protocol == llm_param.LLMClientProtocol.ANTHROPIC:
+    if protocol in (llm_param.LLMClientProtocol.ANTHROPIC, llm_param.LLMClientProtocol.CLAUDE_OAUTH):
         if thinking.type == "disabled":
             return "off"
         if thinking.type == "enabled":
@@ -201,7 +201,7 @@ def get_thinking_picker_data(config: llm_param.LLMConfigParameter) -> ThinkingPi
     model_name = config.model
     thinking = config.thinking
 
-    if protocol in (llm_param.LLMClientProtocol.RESPONSES, llm_param.LLMClientProtocol.CODEX):
+    if protocol in (llm_param.LLMClientProtocol.RESPONSES, llm_param.LLMClientProtocol.CODEX_OAUTH):
         levels = get_levels_for_responses(model_name)
         return ThinkingPickerData(
             options=_build_effort_options(levels),
@@ -209,7 +209,7 @@ def get_thinking_picker_data(config: llm_param.LLMConfigParameter) -> ThinkingPi
             current_value=_get_current_effort_value(thinking),
         )
 
-    if protocol == llm_param.LLMClientProtocol.ANTHROPIC:
+    if protocol in (llm_param.LLMClientProtocol.ANTHROPIC, llm_param.LLMClientProtocol.CLAUDE_OAUTH):
         return ThinkingPickerData(
             options=_build_budget_options(),
             message="Select thinking level:",

klaude_code/core/prompt.py

@@ -101,7 +101,7 @@ def load_system_prompt(
         file_key = _get_file_key(model_name, protocol)
         base_prompt = _load_base_prompt(file_key)
 
-    if protocol == llm_param.LLMClientProtocol.CODEX:
+    if protocol == llm_param.LLMClientProtocol.CODEX_OAUTH:
         # Do not append environment info for Codex protocol
         return base_prompt
 

klaude_code/llm/anthropic/client.py

@@ -6,6 +6,7 @@ from typing import Any, override
 import anthropic
 import httpx
 from anthropic import APIError
+from anthropic.types.beta import BetaTextBlockParam
 from anthropic.types.beta.beta_input_json_delta import BetaInputJSONDelta
 from anthropic.types.beta.beta_raw_content_block_delta_event import BetaRawContentBlockDeltaEvent
 from anthropic.types.beta.beta_raw_content_block_start_event import BetaRawContentBlockStartEvent
@@ -27,13 +28,37 @@ from klaude_code.llm.usage import MetadataTracker
 from klaude_code.protocol import llm_param, model
 from klaude_code.trace import DebugType, log_debug
 
+_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude."
 
-def build_payload(param: llm_param.LLMCallParameter) -> MessageCreateParamsStreaming:
-    """Build Anthropic API request parameters."""
+
+def build_payload(
+    param: llm_param.LLMCallParameter,
+    *,
+    extra_betas: list[str] | None = None,
+) -> MessageCreateParamsStreaming:
+    """Build Anthropic API request parameters.
+
+    Args:
+        param: LLM call parameters.
+        extra_betas: Additional beta flags to prepend to the betas list.
+    """
     messages = convert_history_to_input(param.input, param.model)
     tools = convert_tool_schema(param.tools)
     system = convert_system_to_input(param.system)
 
+    # Add identity block at the beginning of the system prompt
+    identity_block: BetaTextBlockParam = {
+        "type": "text",
+        "text": _IDENTITY,
+        "cache_control": {"type": "ephemeral"},
+    }
+    system = [identity_block, *system]
+
+    betas = ["interleaved-thinking-2025-05-14"]
+    if extra_betas:
+        # Prepend extra betas, avoiding duplicates
+        betas = [b for b in extra_betas if b not in betas] + betas
+
     payload: MessageCreateParamsStreaming = {
         "model": str(param.model),
         "tool_choice": {
@@ -46,7 +71,7 @@ def build_payload(param: llm_param.LLMCallParameter) -> MessageCreateParamsStrea
         "messages": messages,
         "system": system,
         "tools": tools,
-        "betas": ["interleaved-thinking-2025-05-14", "context-1m-2025-08-07"],
+        "betas": betas,
     }
 
     if param.thinking and param.thinking.type == "enabled":

klaude_code/llm/claude/__init__.py

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

klaude_code/llm/claude/client.py

@@ -0,0 +1,95 @@
+import json
+from collections.abc import AsyncGenerator
+from typing import override
+
+import anthropic
+import httpx
+from anthropic import APIError
+
+from klaude_code.auth.claude.exceptions import ClaudeNotLoggedInError
+from klaude_code.auth.claude.oauth import ClaudeOAuth
+from klaude_code.auth.claude.token_manager import ClaudeTokenManager
+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
+
+_CLAUDE_OAUTH_REQUIRED_BETAS: tuple[str, ...] = (
+    "oauth-2025-04-20",
+    "fine-grained-tool-streaming-2025-05-14",
+)
+
+
+@register(llm_param.LLMClientProtocol.CLAUDE_OAUTH)
+class ClaudeClient(LLMClientABC):
+    """Claude OAuth client using Anthropic messages API with Bearer auth token."""
+
+    def __init__(self, config: llm_param.LLMConfigParameter):
+        super().__init__(config)
+
+        if config.base_url:
+            raise ValueError("CLAUDE protocol does not support custom base_url")
+
+        self._token_manager = ClaudeTokenManager()
+        self._oauth = ClaudeOAuth(self._token_manager)
+
+        if not self._token_manager.is_logged_in():
+            raise ClaudeNotLoggedInError("Claude authentication required. Run 'klaude login claude' first.")
+
+        self.client = self._create_client()
+
+    def _create_client(self) -> anthropic.AsyncAnthropic:
+        token = self._oauth.ensure_valid_token()
+        return anthropic.AsyncAnthropic(
+            auth_token=token,
+            timeout=httpx.Timeout(300.0, connect=15.0, read=285.0),
+        )
+
+    def _ensure_valid_token(self) -> None:
+        state = self._token_manager.get_state()
+        if state is None:
+            raise ClaudeNotLoggedInError("Not logged in to Claude. Run 'klaude login claude' first.")
+
+        if state.is_expired():
+            self._oauth.refresh()
+            self.client = self._create_client()
+
+    @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]:
+        self._ensure_valid_token()
+        param = apply_config_defaults(param, self.get_llm_config())
+
+        metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
+
+        # Anthropic OAuth requires the oauth beta flag
+        extra_betas = list(_CLAUDE_OAUTH_REQUIRED_BETAS)
+        payload = build_payload(param, extra_betas=extra_betas)
+
+        # Keep the interleaved-thinking beta in sync with configured thinking.
+        if not (param.thinking and param.thinking.type == "enabled"):
+            payload["betas"] = [b for b in payload.get("betas", []) if b != "interleaved-thinking-2025-05-14"]
+
+        log_debug(
+            json.dumps(payload, ensure_ascii=False, default=str),
+            style="yellow",
+            debug_type=DebugType.LLM_PAYLOAD,
+        )
+
+        stream = self.client.beta.messages.create(
+            **payload,
+            extra_headers={"extra": json.dumps({"session_id": param.session_id}, sort_keys=True)},
+        )
+
+        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/codex/client.py

@@ -67,7 +67,7 @@ CODEX_HEADERS = {
 }
 
 
-@register(llm_param.LLMClientProtocol.CODEX)
+@register(llm_param.LLMClientProtocol.CODEX_OAUTH)
 class CodexClient(LLMClientABC):
     """LLM client for Codex API using ChatGPT subscription."""
 

klaude_code/llm/registry.py

@@ -23,9 +23,11 @@ def _load_protocol(protocol: llm_param.LLMClientProtocol) -> None:
     # Import only the needed module to trigger @register decorator
     if protocol == llm_param.LLMClientProtocol.ANTHROPIC:
         importlib.import_module("klaude_code.llm.anthropic")
+    elif protocol == llm_param.LLMClientProtocol.CLAUDE_OAUTH:
+        importlib.import_module("klaude_code.llm.claude")
     elif protocol == llm_param.LLMClientProtocol.BEDROCK:
         importlib.import_module("klaude_code.llm.bedrock")
-    elif protocol == llm_param.LLMClientProtocol.CODEX:
+    elif protocol == llm_param.LLMClientProtocol.CODEX_OAUTH:
         importlib.import_module("klaude_code.llm.codex")
     elif protocol == llm_param.LLMClientProtocol.OPENAI:
         importlib.import_module("klaude_code.llm.openai_compatible")

klaude_code/protocol/llm_param.py

@@ -12,8 +12,9 @@ class LLMClientProtocol(Enum):
     RESPONSES = "responses"
     OPENROUTER = "openrouter"
     ANTHROPIC = "anthropic"
+    CLAUDE_OAUTH = "claude_oauth"
     BEDROCK = "bedrock"
-    CODEX = "codex"
+    CODEX_OAUTH = "codex_oauth"
     GOOGLE = "google"
 
 

klaude_code/protocol/sub_agent/__init__.py

@@ -37,7 +37,7 @@ class SubAgentProfile:
     """
 
     # Identity - single name used for type, tool_name, config_key, and prompt_key
-    name: str  # e.g., "Task", "Oracle", "Explore"
+    name: str  # e.g., "Task", "Explore", "WebAgent"
 
     # Tool schema
     description: str  # Tool description shown to the main agent
@@ -112,6 +112,5 @@ def sub_agent_tool_names(enabled_only: bool = False, model_name: str | None = No
 
 # Import sub-agent modules to trigger registration
 from klaude_code.protocol.sub_agent import explore as explore  # noqa: E402
-from klaude_code.protocol.sub_agent import oracle as oracle  # noqa: E402
 from klaude_code.protocol.sub_agent import task as task  # noqa: E402
 from klaude_code.protocol.sub_agent import web as web  # noqa: E402

klaude_code/session/session.py

@@ -193,14 +193,14 @@ class Session(BaseModel):
         self.conversation_history.extend(items)
         self._invalidate_messages_count_cache()
 
-        new_user_messages = [
-            it.content for it in items if isinstance(it, model.UserMessageItem) and it.content
-        ]
+        new_user_messages = [it.content for it in items if isinstance(it, model.UserMessageItem) and it.content]
         if new_user_messages:
             if self._user_messages_cache is None:
                 # Build from full history once to ensure correctness when resuming older sessions.
                 self._user_messages_cache = [
-                    it.content for it in self.conversation_history if isinstance(it, model.UserMessageItem) and it.content
+                    it.content
+                    for it in self.conversation_history
+                    if isinstance(it, model.UserMessageItem) and it.content
                 ]
             else:
                 self._user_messages_cache.extend(new_user_messages)

klaude_code/ui/renderers/metadata.py

@@ -11,7 +11,7 @@ from klaude_code.protocol import events, model
 from klaude_code.trace import is_debug_enabled
 from klaude_code.ui.renderers.common import create_grid
 from klaude_code.ui.rich.theme import ThemeKey
-from klaude_code.ui.utils.common import format_number
+from klaude_code.ui.utils.common import format_model_params, format_number
 
 
 def _get_version() -> str:
@@ -184,38 +184,18 @@ def render_welcome(e: events.WelcomeEvent) -> RenderableType:
         (e.llm_config.provider_name, ThemeKey.WELCOME_INFO),
     )
 
-    # Collect all config items to display
-    config_items: list[tuple[str, str]] = []
-
-    if e.llm_config.thinking is not None:
-        if e.llm_config.thinking.reasoning_effort:
-            config_items.append(("reasoning-effort", e.llm_config.thinking.reasoning_effort))
-        if e.llm_config.thinking.reasoning_summary:
-            config_items.append(("reasoning-summary", e.llm_config.thinking.reasoning_summary))
-        if e.llm_config.thinking.budget_tokens:
-            config_items.append(("thinking-budget", str(e.llm_config.thinking.budget_tokens)))
-
-    if e.llm_config.verbosity:
-        config_items.append(("verbosity", str(e.llm_config.verbosity)))
-
-    if pr := e.llm_config.provider_routing:
-        if pr.sort:
-            config_items.append(("provider-sort", str(pr.sort)))
-        if pr.only:
-            config_items.append(("provider-only", ">".join(pr.only)))
-        if pr.order:
-            config_items.append(("provider-order", ">".join(pr.order)))
+    # Use format_model_params for consistent formatting
+    param_strings = format_model_params(e.llm_config)
 
     # Render config items with tree-style prefixes
-    for i, (key, value) in enumerate(config_items):
-        is_last = i == len(config_items) - 1
+    for i, param_str in enumerate(param_strings):
+        is_last = i == len(param_strings) - 1
         prefix = "└─ " if is_last else "├─ "
         panel_content.append_text(
             Text.assemble(
                 ("\n", ThemeKey.WELCOME_INFO),
                 (prefix, ThemeKey.LINES),
-                (f"{key}: ", ThemeKey.WELCOME_INFO),
-                (value, ThemeKey.WELCOME_INFO),
+                (param_str, ThemeKey.WELCOME_INFO),
             )
         )
 

klaude_code/ui/rich/theme.py

@@ -197,8 +197,9 @@ class ThemeKey(str, Enum):
     CONFIG_STATUS_PRIMARY = "config.status.primary"
     CONFIG_STATUS_ERROR = "config.status.error"
     CONFIG_ITEM_NAME = "config.item.name"
+    CONFIG_MODEL_ID = "config.model.id"
     CONFIG_PARAM_LABEL = "config.param.label"
-    CONFIG_PANEL_BORDER = "config.panel.border"
+
 
     def __str__(self) -> str:
         return self.value
@@ -300,13 +301,13 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.RESUME_FLAG.value: "bold reverse " + palette.green,
                 ThemeKey.RESUME_INFO.value: palette.green,
                 # CONFIGURATION DISPLAY
-                ThemeKey.CONFIG_TABLE_HEADER.value: palette.grey1,
+                ThemeKey.CONFIG_TABLE_HEADER.value: "bold " + palette.grey1,
                 ThemeKey.CONFIG_STATUS_OK.value: palette.green,
-                ThemeKey.CONFIG_STATUS_PRIMARY.value: palette.yellow,
+                ThemeKey.CONFIG_STATUS_PRIMARY.value: "bold " + palette.yellow,
                 ThemeKey.CONFIG_STATUS_ERROR.value: palette.red,
                 ThemeKey.CONFIG_ITEM_NAME.value: palette.cyan,
-                ThemeKey.CONFIG_PARAM_LABEL.value: palette.grey1,
-                ThemeKey.CONFIG_PANEL_BORDER.value: palette.grey3,
+                ThemeKey.CONFIG_MODEL_ID.value: palette.blue,
+                ThemeKey.CONFIG_PARAM_LABEL.value: "dim",
                 ThemeKey.CONFIG_PROVIDER.value: palette.cyan + " bold",
             }
         ),

klaude_code/ui/utils/common.py

@@ -1,6 +1,10 @@
 import re
 import subprocess
 from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from klaude_code.protocol.llm_param import LLMConfigModelParameter, OpenRouterProviderRouting
 
 LEADING_NEWLINES_REGEX = re.compile(r"^\n{2,}")
 
@@ -88,3 +92,45 @@ def show_path_with_tilde(path: Path | None = None):
         return f"~/{relative_path}"
     except ValueError:
         return str(path)
+
+
+def format_model_params(model_params: "LLMConfigModelParameter") -> list[str]:
+    """Format model parameters in a concise style.
+
+    Returns a list of formatted parameter strings like:
+    - "reasoning medium"
+    - "thinking budget 10000"
+    - "verbosity 2"
+    - "provider-routing: {...}"
+    """
+    parts: list[str] = []
+
+    if model_params.thinking:
+        if model_params.thinking.reasoning_effort:
+            parts.append(f"reasoning {model_params.thinking.reasoning_effort}")
+        if model_params.thinking.reasoning_summary:
+            parts.append(f"reason-summary {model_params.thinking.reasoning_summary}")
+        if model_params.thinking.budget_tokens:
+            parts.append(f"thinking budget {model_params.thinking.budget_tokens}")
+
+    if model_params.verbosity:
+        parts.append(f"verbosity {model_params.verbosity}")
+
+    if model_params.provider_routing:
+        parts.append(f"provider routing {_format_provider_routing(model_params.provider_routing)}")
+
+    return parts
+
+
+def _format_provider_routing(pr: "OpenRouterProviderRouting") -> str:
+    """Format provider routing settings concisely."""
+    items: list[str] = []
+    if pr.sort:
+        items.append(pr.sort)
+    if pr.only:
+        items.append(">".join(pr.only))
+    if pr.order:
+        items.append(">".join(pr.order))
+    if pr.ignore:
+        items.append(f"ignore {'>'.join(pr.ignore)}")
+    return " · ".join(items) if items else ""

{klaude_code-1.8.0.dist-info → klaude_code-1.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.8.0
+Version: 1.9.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0
@@ -120,11 +120,12 @@ On first run, you'll be prompted to select a model. Your choice is saved as `mai
 | Provider    | Env Variable          | Models                                                                        |
 |-------------|-----------------------|-------------------------------------------------------------------------------|
 | anthropic   | `ANTHROPIC_API_KEY`   | sonnet, opus                                                                  |
+| claude      | N/A (OAuth)           | sonnet@claude, opus@claude (requires Claude Pro/Max subscription)             |
 | openai      | `OPENAI_API_KEY`      | gpt-5.2                                                                       |
 | openrouter  | `OPENROUTER_API_KEY`  | gpt-5.2, gpt-5.2-fast, gpt-5.1-codex-max, sonnet, opus, haiku, kimi, gemini-* |
 | deepseek    | `DEEPSEEK_API_KEY`    | deepseek                                                                      |
 | moonshot    | `MOONSHOT_API_KEY`    | kimi@moonshot                                                                 |
-| codex       | N/A (OAuth)           | gpt-5.2-codex                                                                 |
+| codex       | N/A (OAuth)           | gpt-5.2-codex (requires ChatGPT Pro subscription)                             |
 
 List all configured providers and models:
 
@@ -134,6 +135,26 @@ klaude list
 
 Models from providers without a valid API key are shown as dimmed/unavailable.
 
+#### OAuth Login
+
+For subscription-based providers (Claude Pro/Max, ChatGPT Pro), use the login command:
+
+```bash
+# Interactive provider selection
+klaude login
+
+# Or specify provider directly
+klaude login claude   # Claude Pro/Max subscription
+klaude login codex    # ChatGPT Pro subscription
+```
+
+To logout:
+
+```bash
+klaude logout claude
+klaude logout codex
+```
+
 #### Custom Configuration
 
 User config file: `~/.klaude/klaude-config.yaml`
@@ -240,7 +261,6 @@ provider_list:
 main_model: opus
 
 sub_agent_models:
-  oracle: gpt-4.1
   explore: sonnet
   task: opus
   webagent: sonnet
@@ -269,12 +289,13 @@ provider_list:
 ##### Supported Protocols
 
 - `anthropic` - Anthropic Claude API
+- `claude_oauth` - Claude OAuth (for Claude Pro/Max subscribers)
 - `openai` - OpenAI-compatible API
 - `responses` - OpenAI Responses API (for o-series, GPT-5, Codex)
 - `openrouter` - OpenRouter API
 - `google` - Google Gemini API
 - `bedrock` - AWS Bedrock (uses AWS credentials instead of api_key)
-- `codex` - OpenAI Codex CLI (OAuth-based)
+- `codex_oauth` - OpenAI Codex CLI (OAuth-based, for ChatGPT Pro subscribers)
 
 List configured providers and models:
 
@@ -374,4 +395,3 @@ The main agent can spawn specialized sub-agents for specific tasks:
 | **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 |