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

klaude_code/config/select_model.py

@@ -1,67 +1,131 @@
-from klaude_code.config.config import load_config
+from dataclasses import dataclass
+
+from klaude_code.config.config import ModelEntry, load_config, print_no_available_models_hint
 from klaude_code.trace import log
-from klaude_code.ui.rich.searchable_text import SearchableFormattedList
 
 
-def select_model_from_config(preferred: str | None = None) -> str | None:
+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.
     """
-    Interactive single-choice model selector.
-    for `--select-model`
+
+    return "".join(ch for ch in value.casefold() if ch.isalnum())
+
+
+@dataclass
+class ModelMatchResult:
+    """Result of model matching.
+
+    Attributes:
+        matched_model: The single matched model name, or None if ambiguous/no match.
+        filtered_models: List of filtered models for interactive selection.
+        filter_hint: The filter hint to show (original preferred value), or None.
+        error_message: Error message if no models available, or None.
+    """
+
+    matched_model: str | None
+    filtered_models: list[ModelEntry]
+    filter_hint: str | None
+    error_message: str | None = None
+
+
+def match_model_from_config(preferred: str | None = None) -> ModelMatchResult:
+    """Match model from config without interactive selection.
+
+    If preferred is provided:
+    - Exact match: returns matched_model
+    - Single partial match (case-insensitive): returns matched_model
+    - Multiple matches: returns filtered_models for interactive selection
+    - No matches: returns all models with filter_hint=None
+
+    Returns:
+        ModelMatchResult with match state.
     """
     config = load_config()
-    assert config is not None
-    models = sorted(config.model_list, key=lambda m: m.model_name.lower())
+
+    # Only show models from providers with valid API keys
+    models: list[ModelEntry] = sorted(
+        config.iter_model_entries(only_available=True), key=lambda m: m.model_name.lower()
+    )
 
     if not models:
-        raise ValueError("No models configured. Please update your config.yaml")
+        print_no_available_models_hint()
+        return ModelMatchResult(
+            matched_model=None,
+            filtered_models=[],
+            filter_hint=None,
+            error_message="No models available",
+        )
 
     names: list[str] = [m.model_name for m in models]
-    default_name: str | None = (
-        preferred if preferred in names else (config.main_model if config.main_model in names else None)
-    )
 
-    try:
-        import questionary
+    # Try to match preferred model name
+    filter_hint = preferred
+    if preferred and preferred.strip():
+        preferred = preferred.strip()
+        # Exact match
+        if preferred in names:
+            return ModelMatchResult(matched_model=preferred, filtered_models=models, filter_hint=None)
 
-        choices: list[questionary.Choice] = []
+        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 ModelMatchResult(
+                matched_model=exact_ci_matches[0].model_name, filtered_models=models, filter_hint=None
+            )
 
-        max_model_name_length = max(len(m.model_name) for m in models)
-        for m in models:
-            star = "★ " if m.model_name == config.main_model else "  "
-            fragments = [
-                ("class:t", f"{star}{m.model_name:<{max_model_name_length}}   → "),
-                ("class:b", m.model_params.model or "N/A"),
-                ("class:d", f" {m.provider}"),
+        # Normalized matching (e.g. gpt52 == gpt-5.2, gpt52 in gpt-5.2-2025-...)
+        preferred_norm = _normalize_model_key(preferred)
+        normalized_matches: list[ModelEntry] = []
+        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 "")
             ]
-            # Provide a formatted title for display and a plain text for search.
-            title = SearchableFormattedList(fragments)
-            choices.append(questionary.Choice(title=title, value=m.model_name))
-
-        try:
-            result = questionary.select(
-                message="Select a model:",
-                choices=choices,
-                default=default_name,
-                pointer="→",
-                instruction="↑↓ to move • Enter to select",
-                use_jk_keys=False,
-                use_search_filter=True,
-                style=questionary.Style(
-                    [
-                        ("t", ""),
-                        ("b", "bold"),
-                        ("d", "dim"),
-                        # search filter colors at the bottom
-                        ("search_success", "noinherit fg:ansigreen"),
-                        ("search_none", "noinherit fg:ansired"),
-                        ("question-mark", "fg:ansigreen"),
-                    ]
-                ),
-            ).ask()
-            if isinstance(result, str) and result in names:
-                return result
-        except KeyboardInterrupt:
-            return None
-    except Exception as e:
-        log(f"Failed to use questionary, falling back to default model, {e}")
-        return preferred
+            if len(normalized_matches) == 1:
+                return ModelMatchResult(
+                    matched_model=normalized_matches[0].model_name, filtered_models=models, filter_hint=None
+                )
+
+            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 ModelMatchResult(
+                        matched_model=normalized_matches[0].model_name, filtered_models=models, filter_hint=None
+                    )
+
+        # 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 ModelMatchResult(matched_model=matches[0].model_name, filtered_models=models, filter_hint=None)
+        if matches:
+            # Multiple matches: filter the list for interactive selection
+            return ModelMatchResult(matched_model=None, filtered_models=matches, filter_hint=filter_hint)
+        else:
+            # No matches: show all models without filter hint
+            log(("No matching models found. Showing all models.", "yellow"))
+            return ModelMatchResult(matched_model=None, filtered_models=models, filter_hint=None)
+
+    return ModelMatchResult(matched_model=None, filtered_models=models, filter_hint=None)

klaude_code/config/thinking.py

@@ -0,0 +1,269 @@
+"""Thinking level configuration data and helpers.
+
+This module contains thinking level definitions and helper functions
+that are shared between command layer and UI layer.
+"""
+
+from dataclasses import dataclass
+from typing import Literal
+
+from klaude_code.protocol import llm_param
+
+ReasoningEffort = Literal["high", "medium", "low", "minimal", "none", "xhigh"]
+
+# Thinking level options for different protocols
+RESPONSES_LEVELS = ["low", "medium", "high"]
+RESPONSES_GPT51_LEVELS = ["none", "low", "medium", "high"]
+RESPONSES_GPT52_LEVELS = ["none", "low", "medium", "high", "xhigh"]
+RESPONSES_CODEX_MAX_LEVELS = ["medium", "high", "xhigh"]
+RESPONSES_GEMINI_FLASH_LEVELS = ["minimal", "low", "medium", "high"]
+
+ANTHROPIC_LEVELS: list[tuple[str, int | None]] = [
+    ("off", 0),
+    ("low (2048 tokens)", 2048),
+    ("medium (8192 tokens)", 8192),
+    ("high (31999 tokens)", 31999),
+]
+
+
+def is_openrouter_model_with_reasoning_effort(model_name: str | None) -> bool:
+    """Check if the model is GPT series, Grok or Gemini 3."""
+    if not model_name:
+        return False
+    model_lower = model_name.lower()
+    return model_lower.startswith(("openai/gpt-", "x-ai/grok-", "google/gemini-3"))
+
+
+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 ["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:
+    """Check if the model is GPT-5.1-codex-max."""
+    if not model_name:
+        return False
+    return "codex-max" in model_name.lower()
+
+
+def _is_gemini_flash_model(model_name: str | None) -> bool:
+    """Check if the model is Gemini 3 Flash."""
+    if not model_name:
+        return False
+    return "gemini-3-flash" in model_name.lower()
+
+
+def should_auto_trigger_thinking(model_name: str | None) -> bool:
+    """Check if model should auto-trigger thinking selection on switch."""
+    if not model_name:
+        return False
+    model_lower = model_name.lower()
+    return "gpt-5" in model_lower or "gemini-3" in model_lower or "opus" in model_lower
+
+
+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
+    if _is_gemini_flash_model(model_name):
+        return RESPONSES_GEMINI_FLASH_LEVELS
+    return RESPONSES_LEVELS
+
+
+def format_current_thinking(config: llm_param.LLMConfigParameter) -> str:
+    """Format the current thinking configuration for display."""
+    thinking = config.thinking
+    if not thinking:
+        return "not configured"
+
+    protocol = config.protocol
+
+    if protocol in (llm_param.LLMClientProtocol.RESPONSES, llm_param.LLMClientProtocol.CODEX):
+        if thinking.reasoning_effort:
+            return f"reasoning_effort={thinking.reasoning_effort}"
+        return "not set"
+
+    if protocol == llm_param.LLMClientProtocol.ANTHROPIC:
+        if thinking.type == "disabled":
+            return "off"
+        if thinking.type == "enabled":
+            return f"enabled (budget_tokens={thinking.budget_tokens})"
+        return "not set"
+
+    if protocol == llm_param.LLMClientProtocol.OPENROUTER:
+        if is_openrouter_model_with_reasoning_effort(config.model):
+            if thinking.reasoning_effort:
+                return f"reasoning_effort={thinking.reasoning_effort}"
+        else:
+            if thinking.type == "disabled":
+                return "off"
+            if thinking.type == "enabled":
+                return f"enabled (budget_tokens={thinking.budget_tokens})"
+        return "not set"
+
+    if protocol == llm_param.LLMClientProtocol.OPENAI:
+        if thinking.type == "disabled":
+            return "off"
+        if thinking.type == "enabled":
+            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"
+
+
+# ---------------------------------------------------------------------------
+# Thinking picker data structures
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class ThinkingOption:
+    """A thinking option for selection.
+
+    Attributes:
+        label: Display label for this option (e.g., "low", "medium (8192 tokens)").
+        value: Encoded value string (e.g., "effort:low", "budget:2048").
+    """
+
+    label: str
+    value: str
+
+
+@dataclass
+class ThinkingPickerData:
+    """Data for building thinking picker UI.
+
+    Attributes:
+        options: List of thinking options.
+        message: Prompt message (e.g., "Select reasoning effort:").
+        current_value: Currently selected value, or None.
+    """
+
+    options: list[ThinkingOption]
+    message: str
+    current_value: str | None
+
+
+def _build_effort_options(levels: list[str]) -> list[ThinkingOption]:
+    """Build effort-based thinking options."""
+    return [ThinkingOption(label=level, value=f"effort:{level}") for level in levels]
+
+
+def _build_budget_options() -> list[ThinkingOption]:
+    """Build budget-based thinking options."""
+    return [ThinkingOption(label=label, value=f"budget:{tokens or 0}") for label, tokens in ANTHROPIC_LEVELS]
+
+
+def _get_current_effort_value(thinking: llm_param.Thinking | None) -> str | None:
+    """Get current value for effort-based thinking."""
+    if thinking and thinking.reasoning_effort:
+        return f"effort:{thinking.reasoning_effort}"
+    return None
+
+
+def _get_current_budget_value(thinking: llm_param.Thinking | None) -> str | None:
+    """Get current value for budget-based thinking."""
+    if thinking:
+        if thinking.type == "disabled":
+            return "budget:0"
+        if thinking.budget_tokens:
+            return f"budget:{thinking.budget_tokens}"
+    return None
+
+
+def get_thinking_picker_data(config: llm_param.LLMConfigParameter) -> ThinkingPickerData | None:
+    """Get thinking picker data based on LLM config.
+
+    Returns:
+        ThinkingPickerData with options and current value, or None if protocol doesn't support thinking.
+    """
+    protocol = config.protocol
+    model_name = config.model
+    thinking = config.thinking
+
+    if protocol in (llm_param.LLMClientProtocol.RESPONSES, llm_param.LLMClientProtocol.CODEX):
+        levels = get_levels_for_responses(model_name)
+        return ThinkingPickerData(
+            options=_build_effort_options(levels),
+            message="Select reasoning effort:",
+            current_value=_get_current_effort_value(thinking),
+        )
+
+    if protocol == llm_param.LLMClientProtocol.ANTHROPIC:
+        return ThinkingPickerData(
+            options=_build_budget_options(),
+            message="Select thinking level:",
+            current_value=_get_current_budget_value(thinking),
+        )
+
+    if protocol == llm_param.LLMClientProtocol.OPENROUTER:
+        if is_openrouter_model_with_reasoning_effort(model_name):
+            levels = get_levels_for_responses(model_name)
+            return ThinkingPickerData(
+                options=_build_effort_options(levels),
+                message="Select reasoning effort:",
+                current_value=_get_current_effort_value(thinking),
+            )
+        return ThinkingPickerData(
+            options=_build_budget_options(),
+            message="Select thinking level:",
+            current_value=_get_current_budget_value(thinking),
+        )
+
+    if protocol == llm_param.LLMClientProtocol.OPENAI:
+        return ThinkingPickerData(
+            options=_build_budget_options(),
+            message="Select thinking level:",
+            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
+
+
+def parse_thinking_value(value: str) -> llm_param.Thinking | None:
+    """Parse a thinking value string into a Thinking object.
+
+    Args:
+        value: Encoded value string (e.g., "effort:low", "budget:2048").
+
+    Returns:
+        Thinking object, or None if invalid format.
+    """
+    if value.startswith("effort:"):
+        effort = value[7:]
+        return llm_param.Thinking(reasoning_effort=effort)  # type: ignore[arg-type]
+
+    if value.startswith("budget:"):
+        budget = int(value[7:])
+        if budget == 0:
+            return llm_param.Thinking(type="disabled", budget_tokens=0)
+        return llm_param.Thinking(type="enabled", budget_tokens=budget)
+
+    return None

klaude_code/{const/__init__.py → const.py}

@@ -4,6 +4,21 @@ This module consolidates all magic numbers and configuration values
 that were previously scattered across the codebase.
 """
 
+import os
+from pathlib import Path
+
+
+def _get_int_env(name: str, default: int) -> int:
+    """Get an integer value from environment variable, or return default."""
+    val = os.environ.get(name)
+    if val is None:
+        return default
+    try:
+        return int(val)
+    except ValueError:
+        return default
+
+
 # =============================================================================
 # Agent Configuration
 # =============================================================================
@@ -45,13 +60,12 @@ TODO_REMINDER_TOOL_CALL_THRESHOLD = 10
 READ_CHAR_LIMIT_PER_LINE = 2000
 
 # Maximum number of lines to read from a file
-READ_GLOBAL_LINE_CAP = 2000
-
-# Maximum total characters to read
-READ_MAX_CHARS = 60000
+# Can be overridden via KLAUDE_READ_GLOBAL_LINE_CAP environment variable
+READ_GLOBAL_LINE_CAP = _get_int_env("KLAUDE_READ_GLOBAL_LINE_CAP", 2000)
 
-# Maximum file size in KB for text files
-READ_MAX_KB = 256
+# Maximum total characters to read (truncates beyond this limit)
+# Can be overridden via KLAUDE_READ_MAX_CHARS environment variable
+READ_MAX_CHARS = _get_int_env("KLAUDE_READ_MAX_CHARS", 50000)
 
 # Maximum image file size in bytes (4MB)
 READ_MAX_IMAGE_BYTES = 4 * 1024 * 1024
@@ -62,7 +76,7 @@ BASH_DEFAULT_TIMEOUT_MS = 120000
 
 # -- Tool Output --
 # Maximum length for tool output before truncation
-TOOL_OUTPUT_MAX_LENGTH = 50000
+TOOL_OUTPUT_MAX_LENGTH = 40000
 
 # Characters to show from the beginning of truncated output
 TOOL_OUTPUT_DISPLAY_HEAD = 10000
@@ -91,40 +105,57 @@ INVALID_TOOL_CALL_MAX_LENGTH = 500
 TRUNCATE_DISPLAY_MAX_LINE_LENGTH = 1000
 
 # Maximum lines for truncated display output
-TRUNCATE_DISPLAY_MAX_LINES = 10
+TRUNCATE_DISPLAY_MAX_LINES = 8
 
 # Maximum lines for sub-agent result display
-SUB_AGENT_RESULT_MAX_LINES = 12
+SUB_AGENT_RESULT_MAX_LINES = 50
 
 
 # UI refresh rate (frames per second) for debounced content streaming
-UI_REFRESH_RATE_FPS = 20
+UI_REFRESH_RATE_FPS = 10
+
+# Enable live area for streaming markdown (shows incomplete blocks being typed)
+# When False, only completed markdown blocks are displayed (more stable, less flicker)
+MARKDOWN_STREAM_LIVE_REPAINT_ENABLED = False
 
 # Number of lines to keep visible at bottom of markdown streaming window
-MARKDOWN_STREAM_LIVE_WINDOW = 20
+MARKDOWN_STREAM_LIVE_WINDOW = 6
+
+# Left margin (columns) to reserve when rendering markdown
+MARKDOWN_LEFT_MARGIN = 2
+
+# Right margin (columns) to reserve when rendering markdown
+MARKDOWN_RIGHT_MARGIN = 2
+
+# Status hint text shown after spinner status
+STATUS_HINT_TEXT = " (esc to interrupt)"
+
+# Default spinner status text when idle/thinking
+STATUS_DEFAULT_TEXT = "Thinking …"
 
 # Status shimmer animation
 # Horizontal padding used when computing shimmer band position
 STATUS_SHIMMER_PADDING = 10
-# Duration in seconds for one full shimmer sweep across the text
-STATUS_SHIMMER_SWEEP_SECONDS = 2
 # Half-width of the shimmer band in characters
 STATUS_SHIMMER_BAND_HALF_WIDTH = 5.0
 # Scale factor applied to shimmer intensity when blending colors
 STATUS_SHIMMER_ALPHA_SCALE = 0.7
 
-# Spinner breathing animation
-# Duration in seconds for one full breathe-in + breathe-out cycle
-# Keep in sync with STATUS_SHIMMER_SWEEP_SECONDS for visual consistency
-SPINNER_BREATH_PERIOD_SECONDS = 2
+# Spinner breathing and shimmer animation period
+# Duration in seconds for one full breathe-in + breathe-out cycle (breathing)
+# and one full shimmer sweep across the text (shimmer)
+SPINNER_BREATH_PERIOD_SECONDS: float = 2.0
 
 
 # =============================================================================
 # Debug / Logging
 # =============================================================================
 
-# Default debug log file path
-DEFAULT_DEBUG_LOG_FILE = "debug.log"
+# Default debug log directory (user cache)
+DEFAULT_DEBUG_LOG_DIR = Path.home() / ".klaude" / "logs"
+
+# Default debug log file path (symlink to latest session)
+DEFAULT_DEBUG_LOG_FILE = DEFAULT_DEBUG_LOG_DIR / "debug.log"
 
 # Maximum log file size before rotation (10MB)
 LOG_MAX_BYTES = 10 * 1024 * 1024

klaude_code/core/agent.py

@@ -4,10 +4,10 @@ from collections.abc import AsyncGenerator, Iterable
 from dataclasses import dataclass
 from typing import Protocol
 
-from klaude_code.core.prompt import get_system_prompt as load_system_prompt
+from klaude_code.core.prompt import load_system_prompt
 from klaude_code.core.reminders import Reminder, load_agent_reminders
-from klaude_code.core.task import TaskExecutionContext, TaskExecutor
-from klaude_code.core.tool import TodoContext, get_registry, load_agent_tools
+from klaude_code.core.task import SessionContext, TaskExecutionContext, TaskExecutor
+from klaude_code.core.tool import build_todo_context, get_registry, load_agent_tools
 from klaude_code.llm import LLMClientABC
 from klaude_code.protocol import events, llm_param, model, tools
 from klaude_code.protocol.model import UserInputPayload
@@ -46,7 +46,7 @@ class DefaultModelProfileProvider(ModelProfileProvider):
         model_name = llm_client.model_name
         return AgentProfile(
             llm_client=llm_client,
-            system_prompt=load_system_prompt(model_name, sub_agent_type),
+            system_prompt=load_system_prompt(model_name, llm_client.protocol, sub_agent_type),
             tools=load_agent_tools(model_name, sub_agent_type),
             reminders=load_agent_reminders(model_name, sub_agent_type),
         )
@@ -76,11 +76,10 @@ class Agent:
         profile: AgentProfile,
     ):
         self.session: Session = session
-        self.profile: AgentProfile | None = None
-        # Active task executor, if any
+        self.profile: AgentProfile = profile
         self._current_task: TaskExecutor | None = None
-        # Ensure runtime configuration matches the active model on initialization
-        self.set_model_profile(profile)
+        if not self.session.model_name:
+            self.session.model_name = profile.llm_client.model_name
 
     def cancel(self) -> Iterable[events.Event]:
         """Handle agent cancellation and persist an interrupt marker and tool cancellations.
@@ -93,8 +92,7 @@ class Agent:
         """
         # First, cancel any running task so it stops emitting events.
         if self._current_task is not None:
-            for ui_event in self._current_task.cancel():
-                yield ui_event
+            yield from self._current_task.cancel()
             self._current_task = None
 
         # Record an interrupt marker in the session history
@@ -105,18 +103,18 @@ class Agent:
             debug_type=DebugType.EXECUTION,
         )
 
-    async def run_task(self, user_input: UserInputPayload) -> AsyncGenerator[events.Event, None]:
-        context = TaskExecutionContext(
+    async def run_task(self, user_input: UserInputPayload) -> AsyncGenerator[events.Event]:
+        session_ctx = SessionContext(
             session_id=self.session.id,
-            profile=self._require_profile(),
             get_conversation_history=lambda: self.session.conversation_history,
             append_history=self.session.append_history,
-            tool_registry=get_registry(),
             file_tracker=self.session.file_tracker,
-            todo_context=TodoContext(
-                get_todos=lambda: self.session.todos,
-                set_todos=lambda todos: setattr(self.session, "todos", todos),
-            ),
+            todo_context=build_todo_context(self.session),
+        )
+        context = TaskExecutionContext(
+            session_ctx=session_ctx,
+            profile=self.profile,
+            tool_registry=get_registry(),
             process_reminder=self._process_reminder,
             sub_agent_state=self.session.sub_agent_state,
         )
@@ -130,7 +128,7 @@ class Agent:
         finally:
             self._current_task = None
 
-    async def replay_history(self) -> AsyncGenerator[events.Event, None]:
+    async def replay_history(self) -> AsyncGenerator[events.Event]:
         """Yield UI events reconstructed from saved conversation history."""
 
         if len(self.session.conversation_history) == 0:
@@ -142,7 +140,7 @@ class Agent:
             session_id=self.session.id,
         )
 
-    async def _process_reminder(self, reminder: Reminder) -> AsyncGenerator[events.DeveloperMessageEvent, None]:
+    async def _process_reminder(self, reminder: Reminder) -> AsyncGenerator[events.DeveloperMessageEvent]:
         """Process a single reminder and yield events if it produces output."""
         item = await reminder(self.session)
         if item is not None:
@@ -153,13 +151,7 @@ class Agent:
         """Apply a fully constructed profile to the agent."""
 
         self.profile = profile
-        if not self.session.model_name:
-            self.session.model_name = profile.llm_client.model_name
+        self.session.model_name = profile.llm_client.model_name
 
     def get_llm_client(self) -> LLMClientABC:
-        return self._require_profile().llm_client
-
-    def _require_profile(self) -> AgentProfile:
-        if self.profile is None:
-            raise RuntimeError("Agent profile is not initialized")
-        return self.profile
+        return self.profile.llm_client