klaude-code 2.29.0__tar.gz → 2.30.0__tar.gz

{klaude_code-2.29.0 → klaude_code-2.30.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.29.0
+Version: 2.30.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic[bedrock]>=0.66.0
 Requires-Dist: chardet>=5.2.0,<6

{klaude_code-2.29.0 → klaude_code-2.30.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "2.29.0"
+version = "2.30.0"
 description = "Minimal code agent CLI"
 readme = "README.md"
 requires-python = ">=3.13"

{klaude_code-2.29.0 → klaude_code-2.30.0}/src/klaude_code/agent/compaction/compaction.py

@@ -214,6 +214,7 @@ async def run_compaction(
         summary, fork_usage = await _build_summary_fork(
             session=session,
             cut_index=cut_index,
+            llm_client=llm_client,
             main_profile=main_profile,
             focus=focus,
             has_previous_summary=previous_summary is not None,
@@ -285,6 +286,7 @@ async def _build_summary_fork(
     *,
     session: Session,
     cut_index: int,
+    llm_client: LLMClientABC,
     main_profile: AgentProfile,
     focus: str | None,
     has_previous_summary: bool,
@@ -321,7 +323,7 @@ async def _build_summary_fork(
     call_param.tools = main_profile.tools  # Must match parent; tools=[] would break cache.
     call_param.max_tokens = max_summary_tokens
 
-    stream = await main_profile.llm_client.call(call_param)
+    stream = await llm_client.call(call_param)
     accumulated: list[str] = []
     final_message: message.AssistantMessage | None = None
     async for item in stream:

klaude_code-2.30.0/src/klaude_code/agent/model_fallback.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from klaude_code.agent.compaction.overflow import is_context_overflow
+from klaude_code.agent.runtime.llm import FallbackLLMClient, ModelFallback
+from klaude_code.llm import LLMClientABC
+from klaude_code.protocol import events, message
+from klaude_code.protocol.tools import SubAgentType
+
+
+def fallback_reason(error_message: str) -> str:
+    first_line = error_message.strip().splitlines()[0] if error_message.strip() else "LLM request failed"
+    return first_line[:500]
+
+
+def is_fallbackable_llm_error(error_message: str) -> bool:
+    text = error_message.casefold()
+    if is_context_overflow(error_message):
+        return False
+    fallbackable_markers = (
+        "insufficient_quota",
+        "exceeded your current quota",
+        "quota exceeded",
+        "quota_exceeded",
+        "billing",
+        "credit balance",
+        "credits exhausted",
+        "insufficient credits",
+        "payment required",
+        "model_not_found",
+        "model_not_available",
+        "does not have access to model",
+        "not authorized to access",
+        "permission_denied",
+        "permission denied",
+        "usage_limit_reached",
+    )
+    return any(marker in text for marker in fallbackable_markers)
+
+
+def fallback_llm_client(client: LLMClientABC, error_message: str) -> ModelFallback | None:
+    if not isinstance(client, FallbackLLMClient):
+        return None
+    if not is_fallbackable_llm_error(error_message):
+        return None
+    return client.fallback_to_next()
+
+
+def build_fallback_model_config_warn(
+    *,
+    session_id: str,
+    fallback: ModelFallback,
+    error_message: str,
+    sub_agent_type: SubAgentType | None = None,
+) -> tuple[message.FallbackModelConfigWarnEntry, events.FallbackModelConfigWarnEvent]:
+    reason = fallback_reason(error_message)
+    entry = message.FallbackModelConfigWarnEntry(
+        sub_agent_type=sub_agent_type,
+        from_model=fallback.from_candidate.model_name,
+        from_provider=fallback.from_candidate.provider,
+        to_model=fallback.to_candidate.model_name,
+        to_provider=fallback.to_candidate.provider,
+        reason=reason,
+    )
+    event = events.FallbackModelConfigWarnEvent(
+        session_id=session_id,
+        sub_agent_type=entry.sub_agent_type,
+        from_model=entry.from_model,
+        from_provider=entry.from_provider,
+        to_model=entry.to_model,
+        to_provider=entry.to_provider,
+        reason=entry.reason,
+    )
+    return entry, event

{klaude_code-2.29.0 → klaude_code-2.30.0}/src/klaude_code/agent/prompt_suggestion/prompt_suggestion.py

@@ -21,6 +21,7 @@ from klaude_code.agent.cache_safe import CacheSafeParams, build_cache_safe_messa
 from klaude_code.log import DebugType, log_debug
 from klaude_code.prompts.prompt_suggestion import PROMPT_SUGGESTION_PROMPT
 from klaude_code.protocol import llm_param, message
+from klaude_code.protocol.models import Usage
 from klaude_code.session.session import Session
 
 # Reasoning models (for example gpt-5.4) may spend most of a tiny budget on
@@ -41,6 +42,11 @@ class PromptSuggestionResult:
     drop_reason: str | None = None
 
 
+def _normalized_total_input_tokens(usage: Usage) -> int:
+    # Providers disagree on whether input_tokens includes cached/write tokens.
+    return max(usage.input_tokens, usage.cached_tokens + usage.cache_write_tokens)
+
+
 def should_suggest(session: Session) -> str | None:
     """Return a suppression reason or ``None`` when generation is allowed.
 
@@ -69,16 +75,7 @@ def should_suggest(session: Session) -> str | None:
         # Cache-cold budget, matching claude-code's getParentCacheSuppressReason:
         # skip when the parent turn had to do a lot of fresh (un-cached) work,
         # because the fork inherits similar cost.
-        #
-        # Providers disagree on ``Usage.input_tokens`` semantics (most paths =
-        # total including cached+write; Anthropic-Bedrock = un-cached only).
-        # Use the same robust normalization as CacheTracker: ``max(input_tokens,
-        # cached + cache_write)`` approximates the total prompt size across
-        # providers. See AGENTS.md "Usage Model Semantics".
-        total_input = max(
-            usage.input_tokens,
-            usage.cached_tokens + usage.cache_write_tokens,
-        )
+        total_input = _normalized_total_input_tokens(usage)
         uncached = max(0, total_input - usage.cached_tokens) + usage.output_tokens
         if uncached > _MAX_PARENT_UNCACHED_TOKENS:
             return f"cache_cold(uncached={uncached})"
@@ -148,7 +145,7 @@ async def run_prompt_suggestion(
     raw = message.join_text_parts(final_message.parts) if final_message else "".join(accumulated)
     usage = final_message.usage if final_message else None
     if usage is not None:
-        total = max(usage.input_tokens, usage.cached_tokens + usage.cache_write_tokens)
+        total = _normalized_total_input_tokens(usage)
         hit = (usage.cached_tokens / total) if total > 0 else 0.0
         log_debug(
             f"[PromptSuggestion] usage cache_hit={hit:.2%} "

{klaude_code-2.29.0 → klaude_code-2.30.0}/src/klaude_code/agent/rewind/manager.py

@@ -29,9 +29,6 @@ class RewindManager:
     def register_checkpoint(self, checkpoint_id: int, user_message: str) -> None:
         self._checkpoint_user_messages[checkpoint_id] = user_message
 
-    def get_checkpoint_user_message(self, checkpoint_id: int) -> str | None:
-        return self._checkpoint_user_messages.get(checkpoint_id)
-
     def send_rewind(self, checkpoint_id: int, note: str, rationale: str) -> str:
         if self._pending is not None:
             raise ValueError("Only one rewind can be pending at a time")

{klaude_code-2.29.0 → klaude_code-2.30.0}/src/klaude_code/agent/runtime/agent_ops.py

@@ -16,6 +16,7 @@ from klaude_code.agent.attachments.state import reset_attachment_loaded_flags
 from klaude_code.agent.away_summary import generate_away_summary
 from klaude_code.agent.bash_mode import run_bash_command
 from klaude_code.agent.compaction import CompactionReason, run_compaction
+from klaude_code.agent.model_fallback import build_fallback_model_config_warn, fallback_llm_client
 from klaude_code.agent.prompt_suggestion import run_prompt_suggestion, should_suggest
 from klaude_code.agent.runtime.llm import LLMClients, clone_llm_clients, create_llm_client_for_candidates
 from klaude_code.agent.runtime.sub_agent import SubAgentExecutor
@@ -98,6 +99,7 @@ class AgentOperationHandler:
         self._primary_session_id: str | None = None
         self._title_refresh_tasks: dict[str, asyncio.Task[None]] = {}
         self._prompt_suggestion_tasks: dict[str, asyncio.Task[None]] = {}
+        self._auto_away_summary_tasks: dict[str, asyncio.Task[None]] = {}
 
     async def _request_user_interaction(
         self,
@@ -425,6 +427,19 @@ class AgentOperationHandler:
             )
             task.cancel()
 
+    def _cancel_auto_away_summary(self, session_id: str) -> None:
+        task = self._auto_away_summary_tasks.pop(session_id, None)
+        if task is None or task.done():
+            return
+        log_debug(
+            f"[AwaySummary] cancel stale auto task session={session_id}",
+            debug_type=DebugType.EXECUTION,
+        )
+        task.cancel()
+
+    def cancel_auto_away_summary(self, session_id: str) -> None:
+        self._cancel_auto_away_summary(session_id)
+
     def _schedule_prompt_suggestion(self, agent: Agent) -> None:
         """Fire-and-forget a cache-shared fork to predict the user's next prompt.
 
@@ -530,6 +545,7 @@ class AgentOperationHandler:
         agent = await self.ensure_agent(operation.session_id)
         # New user turn invalidates any pending suggestion for this session.
         self._cancel_prompt_suggestion(operation.session_id)
+        self._cancel_auto_away_summary(operation.session_id)
         await self._emit_event(events.PromptSuggestionClearedEvent(session_id=operation.session_id))
         frozen_input = self._freeze_user_input_for_history(
             operation.input,
@@ -572,6 +588,7 @@ class AgentOperationHandler:
         agent.follow_up(operation.input)
 
     async def run_bash(self, operation: op.RunBashOperation) -> None:
+        self._cancel_auto_away_summary(operation.session_id)
         agent = await self.ensure_agent(operation.session_id)
 
         existing_active = self.get_active_task(operation.id)
@@ -629,6 +646,7 @@ class AgentOperationHandler:
 
     async def continue_agent(self, operation: op.ContinueAgentOperation) -> None:
         """Continue agent execution without adding a new user message."""
+        self._cancel_auto_away_summary(operation.session_id)
         agent = await self.ensure_agent(operation.session_id)
 
         existing_active = self.get_active_task(operation.id)
@@ -652,6 +670,7 @@ class AgentOperationHandler:
         )
 
     async def compact_session(self, operation: op.CompactSessionOperation) -> None:
+        self._cancel_auto_away_summary(operation.session_id)
         agent = await self.ensure_agent(operation.session_id)
 
         if self._cancel_tasks_for_sessions({operation.session_id}):
@@ -694,6 +713,35 @@ class AgentOperationHandler:
             )
             return
 
+        user_messages_snapshot = tuple(agent.session.user_messages)
+
+        async def _runner() -> None:
+            await self._run_away_summary_task(operation, user_messages_snapshot=user_messages_snapshot)
+
+        await self.run_background_operation(
+            operation_id=operation.id,
+            session_id=operation.session_id,
+            runner=_runner,
+        )
+
+        if operation.source == "auto":
+            active = self.get_active_task(operation.id)
+            if active is not None:
+                self._auto_away_summary_tasks[operation.session_id] = active.task
+
+                def _cleanup(completed: asyncio.Task[None]) -> None:
+                    if self._auto_away_summary_tasks.get(operation.session_id) is completed:
+                        self._auto_away_summary_tasks.pop(operation.session_id, None)
+
+                active.task.add_done_callback(_cleanup)
+
+    async def _run_away_summary_task(
+        self,
+        operation: op.GenerateAwaySummaryOperation,
+        *,
+        user_messages_snapshot: tuple[str, ...],
+    ) -> None:
+        agent = await self.ensure_agent(operation.session_id)
         clients = self.get_session_llm_clients(operation.session_id)
         fast_client = clients.get_fast_client()
 
@@ -709,6 +757,19 @@ class AgentOperationHandler:
                 )
                 return
 
+            if operation.source == "auto" and tuple(agent.session.user_messages) != user_messages_snapshot:
+                log_debug(
+                    f"[AwaySummary] skip (stale auto result, source={operation.source})",
+                    debug_type=DebugType.EXECUTION,
+                )
+                return
+            if _has_summary_since_last_user_turn(agent.session):
+                log_debug(
+                    f"[AwaySummary] skip (dedup after generation, source={operation.source})",
+                    debug_type=DebugType.EXECUTION,
+                )
+                return
+
             entry = message.AwaySummaryEntry(text=text, source=operation.source)
             agent.session.append_history([entry])
             await self._emit_event(
@@ -722,6 +783,7 @@ class AgentOperationHandler:
         agent = await self.ensure_agent(session_id)
         old_session_id = agent.session.id
         self._cancel_prompt_suggestion(old_session_id)
+        self._cancel_auto_away_summary(old_session_id)
         old_runtime = self._get_session_actor(old_session_id)
         if old_runtime is None:
             raise RuntimeError(f"Missing runtime for session {old_session_id}")
@@ -776,6 +838,7 @@ class AgentOperationHandler:
         """Switch the active session to an already-forked session and replay its history."""
         agent = await self.ensure_agent(session_id)
         old_session_id = agent.session.id
+        self._cancel_auto_away_summary(old_session_id)
         old_runtime = self._get_session_actor(old_session_id)
         if old_runtime is None:
             raise RuntimeError(f"Missing runtime for session {old_session_id}")
@@ -957,16 +1020,37 @@ class AgentOperationHandler:
         try:
             await self._emit_event(events.CompactionStartEvent(session_id=session_id, reason=reason))
             log_debug(f"[Compact:{reason}] start", debug_type=DebugType.RESPONSE)
-            compact_client = self.get_session_llm_clients(session_id).get_compact_client()
-            result = await run_compaction(
-                session=agent.session,
-                reason=CompactionReason(reason),
-                focus=operation.focus,
-                llm_client=compact_client,
-                llm_config=compact_client.get_llm_config(),
-                cancel=cancel_event,
-                main_profile=agent.profile,
-            )
+            session_clients = self.get_session_llm_clients(session_id)
+            while True:
+                compact_client = session_clients.get_compact_client()
+                try:
+                    result = await run_compaction(
+                        session=agent.session,
+                        reason=CompactionReason(reason),
+                        focus=operation.focus,
+                        llm_client=compact_client,
+                        llm_config=compact_client.get_llm_config(),
+                        cancel=cancel_event,
+                        main_profile=agent.profile,
+                    )
+                    break
+                except asyncio.CancelledError:
+                    raise
+                except Exception as exc:
+                    fallback = fallback_llm_client(compact_client, str(exc))
+                    if fallback is None:
+                        raise
+                    entry, fallback_event = build_fallback_model_config_warn(
+                        session_id=session_id,
+                        fallback=fallback,
+                        error_message=str(exc),
+                    )
+                    agent.session.append_history([entry])
+                    if session_clients.compact is None and compact_client is session_clients.main:
+                        agent.set_model_profile(
+                            self._model_profile_provider.build_profile(compact_client, work_dir=agent.session.work_dir)
+                        )
+                    await self._emit_event(fallback_event)
             log_debug(f"[Compact:{reason}] result", str(result.to_entry()), debug_type=DebugType.RESPONSE)
             reset_attachment_loaded_flags(agent.session.file_tracker)
             agent.session.append_history([result.to_entry()])
@@ -1053,6 +1137,9 @@ class AgentRunner:
     async def generate_away_summary(self, operation: op.GenerateAwaySummaryOperation) -> None:
         await self._operation_handler.generate_away_summary(operation)
 
+    def cancel_auto_away_summary(self, session_id: str) -> None:
+        self._operation_handler.cancel_auto_away_summary(session_id)
+
     async def clear_session(self, session_id: str) -> None:
         await self._operation_handler.clear_session(session_id)
 

{klaude_code-2.29.0 → klaude_code-2.30.0}/src/klaude_code/agent/runtime/config_ops.py

@@ -97,6 +97,7 @@ class ConfigHandler:
         return "not set"
 
     async def handle_change_model(self, operation: op.ChangeModelOperation) -> None:
+        self._agent_runner.cancel_auto_away_summary(operation.session_id)
         agent = await self._agent_runner.ensure_agent(operation.session_id)
         llm_config, llm_client_name = await self._model_switcher.change_model(
             agent,
@@ -133,6 +134,7 @@ class ConfigHandler:
             )
 
     async def handle_change_thinking(self, operation: op.ChangeThinkingOperation) -> None:
+        self._agent_runner.cancel_auto_away_summary(operation.session_id)
         agent = await self._agent_runner.ensure_agent(operation.session_id)
 
         if operation.thinking is None:
@@ -163,6 +165,7 @@ class ConfigHandler:
             )
 
     async def handle_change_sub_agent_model(self, operation: op.ChangeSubAgentModelOperation) -> None:
+        self._agent_runner.cancel_auto_away_summary(operation.session_id)
         agent = await self._agent_runner.ensure_agent(operation.session_id)
         session_clients = self._agent_runner.get_session_llm_clients(agent.session.id)
         config = load_config()
@@ -207,6 +210,7 @@ class ConfigHandler:
         )
 
     async def handle_change_compact_model(self, operation: op.ChangeCompactModelOperation) -> None:
+        self._agent_runner.cancel_auto_away_summary(operation.session_id)
         agent = await self._agent_runner.ensure_agent(operation.session_id)
         session_clients = self._agent_runner.get_session_llm_clients(agent.session.id)
         config = load_config()
@@ -217,8 +221,11 @@ class ConfigHandler:
             agent.compact_llm_client = None
             display_model = "(inherit from main agent)"
         else:
-            llm_config = config.get_model_config(model_name)
-            new_client = create_llm_client(llm_config)
+            candidates = config.iter_model_config_candidates_with_preference_fallback(model_name, config.compact_model)
+            if not candidates:
+                _ = config.get_model_config(model_name)
+                raise ValueError(f"Unknown model: {model_name}")
+            new_client = create_llm_client_for_candidates(candidates)
             session_clients.compact = new_client
             agent.compact_llm_client = new_client
             display_model = new_client.model_name
@@ -282,6 +289,8 @@ class ConfigHandler:
         return True
 
     async def handle_request_model(self, operation: op.RequestModelOperation) -> None:
+        self._agent_runner.cancel_auto_away_summary(operation.session_id)
+
         async def _runner() -> None:
             initial_search_text = operation.initial_search_text
             if initial_search_text is not None:
@@ -362,6 +371,8 @@ class ConfigHandler:
         )
 
     async def handle_request_thinking(self, operation: op.RequestThinkingOperation) -> None:
+        self._agent_runner.cancel_auto_away_summary(operation.session_id)
+
         async def _runner() -> None:
             agent = await self._agent_runner.ensure_agent(operation.session_id)
             llm_config = agent.profile.llm_client.get_llm_config()
@@ -426,6 +437,8 @@ class ConfigHandler:
         )
 
     async def handle_request_sub_agent_model(self, operation: op.RequestSubAgentModelOperation) -> None:
+        self._agent_runner.cancel_auto_away_summary(operation.session_id)
+
         async def _runner() -> None:
             agent = await self._agent_runner.ensure_agent(operation.session_id)
             session_clients = self._agent_runner.get_session_llm_clients(agent.session.id)
@@ -608,6 +621,7 @@ class ConfigHandler:
         )
 
     async def handle_get_session_stats(self, operation: op.GetSessionStatsOperation) -> None:
+        self._agent_runner.cancel_auto_away_summary(operation.session_id)
         agent = await self._agent_runner.ensure_agent(operation.session_id)
         await self._emit_event(
             events.SessionStatsEvent(

{klaude_code-2.29.0 → klaude_code-2.30.0}/src/klaude_code/agent/runtime/dispatcher.py

@@ -230,6 +230,9 @@ class OperationDispatcher:
     async def handle_generate_away_summary(self, operation: op.GenerateAwaySummaryOperation) -> None:
         await self._agent_runner.generate_away_summary(operation)
 
+    def cancel_auto_away_summary(self, session_id: str) -> None:
+        self._agent_runner.cancel_auto_away_summary(session_id)
+
     async def handle_change_model(self, operation: op.ChangeModelOperation) -> None:
         await self._config_handler.handle_change_model(operation)
 

{klaude_code-2.29.0 → klaude_code-2.30.0}/src/klaude_code/agent/runtime/llm.py

@@ -22,6 +22,21 @@ def _default_sub_clients() -> dict[SubAgentType, LLMClientABC]:
     return {}
 
 
+class ModelResolutionError(ValueError):
+    """Raised when a configured model preference cannot be resolved.
+
+    Carries which role (main/fast/compact/sub-agent) failed so callers can
+    produce a precise error message instead of conflating roles.
+    """
+
+    def __init__(self, role: str, model_preference: ModelPreference, original: Exception) -> None:
+        self.role = role
+        self.model_preference = model_preference
+        self.original = original
+        pref_text = format_model_preference(model_preference) or "<unset>"
+        super().__init__(f"{role} '{pref_text}' could not be resolved: {original}")
+
+
 @dataclass(frozen=True)
 class ModelFallback:
     """A runtime switch from one concrete model candidate to another."""
@@ -44,6 +59,7 @@ class FallbackLLMClient(LLMClientABC):
     @classmethod
     @override
     def create(cls, config: llm_param.LLMConfigParameter) -> LLMClientABC:
+        del cls
         del config
         raise NotImplementedError("FallbackLLMClient must be constructed with candidates")
 
@@ -117,14 +133,6 @@ class LLMClients:
     fast: LLMClientABC | None = None
     compact: LLMClientABC | None = None
 
-    def get_client(self, sub_agent_type: SubAgentType | None = None) -> LLMClientABC:
-        if sub_agent_type is None:
-            return self.main
-        client = self.sub_clients.get(sub_agent_type)
-        if client is not None:
-            return client
-        return self.main
-
     def get_compact_client(self) -> LLMClientABC:
         return self.compact or self.main
 
@@ -147,8 +155,11 @@ def build_llm_clients(
         else config.iter_model_config_candidates(model_pref)
     )
     if not main_candidates:
-        _ = config.get_first_available_model(model_pref)
-        raise ValueError("No available main_model candidates")
+        try:
+            _ = config.get_first_available_model(model_pref)
+        except ValueError as exc:
+            raise ModelResolutionError("main_model", model_pref, exc) from exc
+        raise ModelResolutionError("main_model", model_pref, ValueError("No available main_model candidates"))
     llm_config = main_candidates[0].llm_config
     model_name = (
         format_model_preference([candidate.selector for candidate in main_candidates])
@@ -165,7 +176,10 @@ def build_llm_clients(
     main_client = create_llm_client_for_candidates(main_candidates)
 
     fast_client: LLMClientABC | None = None
-    selected_fast_model = config.get_first_available_model(config.fast_model)
+    try:
+        selected_fast_model = config.get_first_available_model(config.fast_model)
+    except ValueError as exc:
+        raise ModelResolutionError("fast_model", config.fast_model, exc) from exc
     if selected_fast_model is not None:
         fast_llm_config = config.get_model_config(selected_fast_model)
         log_debug(
@@ -176,15 +190,20 @@ def build_llm_clients(
         fast_client = create_llm_client(fast_llm_config)
 
     compact_client: LLMClientABC | None = None
-    selected_compact_model = config.get_first_available_model(config.compact_model)
-    if selected_compact_model is not None:
-        compact_llm_config = config.get_model_config(selected_compact_model)
+    compact_candidates = config.iter_model_config_candidates(config.compact_model)
+    if compact_candidates:
+        compact_llm_config = compact_candidates[0].llm_config
         log_debug(
             "Compact LLM config",
             compact_llm_config.model_dump_json(exclude_none=True),
             debug_type=DebugType.LLM_CONFIG,
         )
-        compact_client = create_llm_client(compact_llm_config)
+        compact_client = create_llm_client_for_candidates(compact_candidates)
+    elif config.compact_model is not None:
+        try:
+            _ = config.get_first_available_model(config.compact_model)
+        except ValueError as exc:
+            raise ModelResolutionError("compact_model", config.compact_model, exc) from exc
 
     if skip_sub_agents:
         return LLMClients(main=main_client, main_model_alias=model_name, fast=fast_client, compact=compact_client)
@@ -192,19 +211,24 @@ def build_llm_clients(
     helper = SubAgentModelResolver(config)
     sub_agent_candidates = helper.build_sub_agent_client_candidates()
     user_sub_agent_models = config.get_user_sub_agent_models()
-    for model_pref in user_sub_agent_models.values():
-        if not config.iter_model_config_candidates(model_pref):
-            _ = config.get_first_available_model(model_pref)
+    for role_key, sub_pref in user_sub_agent_models.items():
+        if not config.iter_model_config_candidates(sub_pref):
+            try:
+                _ = config.get_first_available_model(sub_pref)
+            except ValueError as exc:
+                raise ModelResolutionError(f"sub_agent_models.{role_key}", sub_pref, exc) from exc
 
     sub_clients: dict[SubAgentType, LLMClientABC] = {}
     for sub_agent_type, candidates in sub_agent_candidates.items():
         try:
             sub_clients[sub_agent_type] = FallbackLLMClient(candidates)
-        except ValueError:
+        except ValueError as exc:
             profile = get_sub_agent_profile(sub_agent_type)
             role_key = profile.name
             if role_key in user_sub_agent_models:
-                raise
+                raise ModelResolutionError(
+                    f"sub_agent_models.{role_key}", user_sub_agent_models[role_key], exc
+                ) from exc
             log_debug(
                 f"Sub-agent '{sub_agent_type}' builtin models not available, falling back to main model",
                 debug_type=DebugType.LLM_CONFIG,

{klaude_code-2.29.0 → klaude_code-2.30.0}/src/klaude_code/agent/skill_inventory.py

@@ -1,5 +1,17 @@
 from __future__ import annotations
 
+from collections.abc import Callable
+from typing import TypeVar
+
+_T = TypeVar("_T")
+
+
+def _safe_skill_call(fn: Callable[[], _T], default: _T) -> _T:
+    try:
+        return fn()
+    except Exception:
+        return default
+
 
 def get_skill_names_by_location() -> dict[str, list[str]]:
     """Return available skill names grouped by location.
@@ -15,8 +27,8 @@ def get_skill_names_by_location() -> dict[str, list[str]]:
     except Exception:
         return {}
 
-    result: dict[str, list[str]] = {"user": [], "project": [], "system": []}
-    try:
+    def _collect() -> dict[str, list[str]]:
+        result: dict[str, list[str]] = {"user": [], "project": [], "system": []}
         for name, _desc, location in get_available_skills():
             if location == "user":
                 result["user"].append(name)
@@ -24,16 +36,16 @@ def get_skill_names_by_location() -> dict[str, list[str]]:
                 result["project"].append(name)
             elif location == "system":
                 result["system"].append(name)
-    except Exception:
-        return {}
 
-    if not result["user"] and not result["project"] and not result["system"]:
-        return {}
+        if not result["user"] and not result["project"] and not result["system"]:
+            return {}
+
+        result["user"].sort()
+        result["project"].sort()
+        result["system"].sort()
+        return result
 
-    result["user"].sort()
-    result["project"].sort()
-    result["system"].sort()
-    return result
+    return _safe_skill_call(_collect, {})
 
 
 def get_skill_warnings_by_location() -> dict[str, list[str]]:
@@ -44,7 +56,4 @@ def get_skill_warnings_by_location() -> dict[str, list[str]]:
     except Exception:
         return {}
 
-    try:
-        return get_skill_warnings_by_location()
-    except Exception:
-        return {}
+    return _safe_skill_call(get_skill_warnings_by_location, {})