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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.28.0
+Version: 2.30.0
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic[bedrock]>=0.66.0
 Requires-Dist: chardet>=5.2.0,<6
@@ -8,13 +8,14 @@ Requires-Dist: diff-match-patch>=20241021
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: fastapi
 Requires-Dist: google-genai>=1.56.0
+Requires-Dist: httpx[socks]>=0.28.1
 Requires-Dist: markdown-it-py>=4.0.0
 Requires-Dist: openai>=2.24.0
 Requires-Dist: prompt-toolkit>=3.0.52
 Requires-Dist: pydantic>=2.11.7
-Requires-Dist: python-socks>=2.8.1
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=14.1.0
+Requires-Dist: socksio>=1.0.0
 Requires-Dist: sse-starlette
 Requires-Dist: trafilatura>=2.0.0
 Requires-Dist: typer>=0.17.3

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

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "2.28.0"
+version = "2.30.0"
 description = "Minimal code agent CLI"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -15,13 +15,14 @@ dependencies = [
     "filelock>=3.20.3",
     "fastapi",
     "google-genai>=1.56.0",
+    "httpx[socks]>=0.28.1",
     "markdown-it-py>=4.0.0",
     "openai>=2.24.0",
     "prompt-toolkit>=3.0.52",
     "pydantic>=2.11.7",
-    "python-socks>=2.8.1",
     "pyyaml>=6.0.2",
     "rich>=14.1.0",
+    "socksio>=1.0.0",
     "sse-starlette",
     "trafilatura>=2.0.0",
     "typer>=0.17.3",

{klaude_code-2.28.0 → klaude_code-2.30.0}/src/klaude_code/agent/agent.py

@@ -38,6 +38,7 @@ class Agent:
         self.profile: AgentProfile = profile
         self.compact_llm_client: LLMClientABC | None = compact_llm_client
         self._current_task: TaskExecutor | None = None
+        self._follow_up_queue: list[UserInputPayload] = [item.model_copy(deep=True) for item in session.follow_up_queue]
         self._last_interrupt_show_notice = True
         self._last_interrupt_prefill_text: str | None = None
         self.request_user_interaction = request_user_interaction
@@ -54,6 +55,37 @@ class Agent:
         self._last_interrupt_prefill_text = None
         return text
 
+    def follow_up(self, user_input: UserInputPayload) -> int:
+        """Queue a user message to run after the active task completes."""
+
+        self._follow_up_queue.append(user_input)
+        self.session.set_follow_up_queue(self._follow_up_queue)
+        return len(self._follow_up_queue)
+
+    def follow_up_count(self) -> int:
+        return len(self._follow_up_queue)
+
+    def follow_up_snapshot(self) -> tuple[UserInputPayload, ...]:
+        return tuple(self._follow_up_queue)
+
+    def pop_all_follow_up(self) -> tuple[UserInputPayload, ...]:
+        messages = tuple(self._follow_up_queue)
+        self._follow_up_queue.clear()
+        self.session.set_follow_up_queue(self._follow_up_queue)
+        return messages
+
+    def peek_next_follow_up(self) -> UserInputPayload | None:
+        if not self._follow_up_queue:
+            return None
+        return self._follow_up_queue[0]
+
+    def pop_next_follow_up(self) -> UserInputPayload | None:
+        if not self._follow_up_queue:
+            return None
+        message = self._follow_up_queue.pop(0)
+        self.session.set_follow_up_queue(self._follow_up_queue)
+        return message
+
     def on_interrupt(self) -> Iterable[events.Event]:
         """Handle an interrupt by emitting best-effort cleanup events.
 

{klaude_code-2.28.0 → klaude_code-2.30.0}/src/klaude_code/agent/agent_profile.py

@@ -44,7 +44,7 @@ MAIN_AGENT_COMMON_BASE_TOOLS: list[str] = [tools.BASH, tools.READ]
 MAIN_AGENT_GPT5_DIFF_TOOLS: list[str] = [tools.APPLY_PATCH, tools.TODO_WRITE]
 MAIN_AGENT_NON_GPT5_DIFF_TOOLS: list[str] = [tools.EDIT, tools.WRITE, tools.TODO_WRITE]
 MAIN_AGENT_COMMON_TOOLS: list[str] = [
-    tools.HANDOFF,
+    # tools.HANDOFF,
     tools.AGENT,
     tools.WEB_FETCH,
     tools.WEB_SEARCH,

{klaude_code-2.28.0 → klaude_code-2.30.0}/src/klaude_code/agent/attachments/files.py

@@ -15,6 +15,7 @@ from klaude_code.prompts.attachments import (
     TOOL_RESULT_TEMPLATE,
 )
 from klaude_code.protocol import message, tools
+from klaude_code.protocol.input_syntax import AT_FILE_PATTERN
 from klaude_code.protocol.models import (
     AtFileImagesUIItem,
     AtFileOp,
@@ -61,18 +62,6 @@ def _fmt_paste_file_hint(pasted_files: dict[str, str]) -> str:
     return PASTE_FILE_HINT_TEMPLATE.format(mapping=mapping)
 
 
-# Match @ preceded by whitespace, start of line, or -> (ReadTool line number arrow)
-# Supports optional line range suffix: @file.txt#L10-20 or @file.txt#L10.
-_AT_PLAIN_STOP_CHARS = (
-    r"\u3000-\u303f"
-    r"\uff01-\uff0f"
-    r"\uff1a-\uff20"
-    r"\uff3b-\uff40"
-    r"\uff5b-\uff65"
-)
-AT_FILE_PATTERN = re.compile(rf'(?:(?<!\S)|(?<=\u2192))@("(?P<quoted>[^"]+)"|(?P<plain>[^\s{_AT_PLAIN_STOP_CHARS}]+))')
-
-
 class AtFileRef:
     """Parsed @file reference with optional line range."""
 

{klaude_code-2.28.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.28.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.28.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.28.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.
 
@@ -438,6 +453,12 @@ class AgentOperationHandler:
         # session is the only one that benefits from a suggestion.
         if agent.session.sub_agent_state is not None:
             return
+        if agent.follow_up_count() > 0:
+            log_debug(
+                f"[PromptSuggestion] skip session={session_id} reason=follow-up queue pending",
+                debug_type=DebugType.EXECUTION,
+            )
+            return
         suppress = should_suggest(agent.session)
         if suppress is not None:
             log_debug(
@@ -524,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,
@@ -561,7 +583,12 @@ class AgentOperationHandler:
             session_id=operation.session_id,
         )
 
+    async def follow_up_agent(self, operation: op.FollowUpAgentOperation) -> None:
+        agent = await self.ensure_agent(operation.session_id)
+        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)
@@ -619,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)
@@ -642,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}):
@@ -684,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()
 
@@ -699,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(
@@ -712,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}")
@@ -766,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}")
@@ -947,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()])
@@ -1031,6 +1125,9 @@ class AgentRunner:
     async def run_agent(self, operation: op.RunAgentOperation) -> None:
         await self._operation_handler.run_agent(operation)
 
+    async def follow_up_agent(self, operation: op.FollowUpAgentOperation) -> None:
+        await self._operation_handler.follow_up_agent(operation)
+
     async def continue_agent(self, operation: op.ContinueAgentOperation) -> None:
         await self._operation_handler.continue_agent(operation)
 
@@ -1040,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.28.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.28.0 → klaude_code-2.30.0}/src/klaude_code/agent/runtime/dispatcher.py

@@ -215,6 +215,9 @@ class OperationDispatcher:
     async def handle_run_agent(self, operation: op.RunAgentOperation) -> None:
         await self._agent_runner.run_agent(operation)
 
+    async def handle_follow_up_agent(self, operation: op.FollowUpAgentOperation) -> None:
+        await self._agent_runner.follow_up_agent(operation)
+
     async def handle_run_bash(self, operation: op.RunBashOperation) -> None:
         await self._bash_runner.run_bash(operation)
 
@@ -227,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)