klaude-code 2.8.1__py3-none-any.whl → 2.9.0__py3-none-any.whl

klaude_code/config/config.py

@@ -44,13 +44,6 @@ def parse_env_var_syntax(value: str | None) -> tuple[str | None, str | None]:
     return None, value
 
 
-def is_env_var_syntax(value: str | None) -> bool:
-    """Check if a value uses ${ENV_VAR} syntax."""
-    if value is None:
-        return False
-    return _ENV_VAR_PATTERN.match(value) is not None
-
-
 def resolve_api_key(value: str | None) -> str | None:
     """Resolve an API key value, expanding ${ENV_VAR} syntax if present."""
     _, resolved = parse_env_var_syntax(value)
@@ -70,6 +63,7 @@ class ModelConfig(llm_param.LLMConfigModelParameter):
 class ProviderConfig(llm_param.LLMConfigProviderParameter):
     """Full provider configuration (used in merged config)."""
 
+    disabled: bool = False
     model_list: list[ModelConfig] = Field(default_factory=lambda: [])
 
     def get_resolved_api_key(self) -> str | None:
@@ -141,6 +135,7 @@ class UserProviderConfig(BaseModel):
 
     provider_name: str
     protocol: llm_param.LLMClientProtocol | None = None
+    disabled: bool = False
     base_url: str | None = None
     api_key: str | None = None
     is_azure: bool = False
@@ -290,6 +285,9 @@ class Config(BaseModel):
             if requested_provider is not None and provider.provider_name.casefold() != requested_provider.casefold():
                 continue
 
+            if provider.disabled:
+                continue
+
             api_key = provider.get_resolved_api_key()
             if (
                 provider.protocol
@@ -303,7 +301,11 @@ class Config(BaseModel):
             ):
                 continue
 
-            if any(m.model_name == requested_model for m in provider.model_list):
+            for model in provider.model_list:
+                if model.model_name != requested_model:
+                    continue
+                if model.disabled:
+                    continue
                 return requested_model, provider.provider_name
 
         return None
@@ -315,6 +317,11 @@ class Config(BaseModel):
             if requested_provider is not None and provider.provider_name.casefold() != requested_provider.casefold():
                 continue
 
+            if provider.disabled:
+                if requested_provider is not None:
+                    raise ValueError(f"Provider '{provider.provider_name}' is disabled for: {model_name}")
+                continue
+
             # Resolve ${ENV_VAR} syntax for api_key
             api_key = provider.get_resolved_api_key()
 
@@ -339,7 +346,15 @@ class Config(BaseModel):
             for model in provider.model_list:
                 if model.model_name != requested_model:
                     continue
-                provider_dump = provider.model_dump(exclude={"model_list"})
+
+                if model.disabled:
+                    if requested_provider is not None:
+                        raise ValueError(
+                            f"Model '{requested_model}' is disabled in provider '{provider.provider_name}' for: {model_name}"
+                        )
+                    break
+
+                provider_dump = provider.model_dump(exclude={"model_list", "disabled"})
                 provider_dump["api_key"] = api_key
                 return llm_param.LLMConfigParameter(
                     **provider_dump,
@@ -353,7 +368,7 @@ class Config(BaseModel):
 
         Args:
             only_available: If True, only return models from providers with valid API keys.
-            include_disabled: If False, exclude models with disabled=True.
+            include_disabled: If False, exclude models/providers with disabled=True.
         """
         return [
             ModelEntry(
@@ -362,7 +377,8 @@ class Config(BaseModel):
                 **model.model_dump(exclude={"model_name"}),
             )
             for provider in self.provider_list
-            if not only_available or not provider.is_api_key_missing()
+            if include_disabled or not provider.disabled
+            if not only_available or (not provider.disabled and not provider.is_api_key_missing())
             for model in provider.model_list
             if include_disabled or not model.disabled
         ]
@@ -374,13 +390,6 @@ class Config(BaseModel):
                 return True
         return False
 
-    def get_first_available_nano_banana_model(self) -> str | None:
-        """Get the first available nano-banana model, or None."""
-        for entry in self.iter_model_entries(only_available=True, include_disabled=False):
-            if "nano-banana" in entry.model_name:
-                return entry.model_name
-        return None
-
     def get_first_available_image_model(self) -> str | None:
         """Get the first available image generation model, or None."""
         for entry in self.iter_model_entries(only_available=True, include_disabled=False):
@@ -406,7 +415,21 @@ class Config(BaseModel):
         user_config.theme = self.theme
         # Note: provider_list is NOT synced - user providers are already in user_config
 
-        config_dict = user_config.model_dump(mode="json", exclude_none=True, exclude_defaults=True)
+        # Keep the saved file compact (exclude defaults), but preserve explicit
+        # overrides inside provider_list (e.g. `disabled: false` to re-enable a
+        # builtin provider that is disabled by default).
+        config_dict = user_config.model_dump(
+            mode="json",
+            exclude_none=True,
+            exclude_defaults=True,
+            exclude={"provider_list"},
+        )
+
+        provider_list = [
+            p.model_dump(mode="json", exclude_none=True, exclude_unset=True) for p in (user_config.provider_list or [])
+        ]
+        if provider_list:
+            config_dict["provider_list"] = provider_list
 
         def _save_config() -> None:
             config_path.parent.mkdir(parents=True, exist_ok=True)
@@ -454,12 +477,12 @@ def _get_builtin_config() -> Config:
 def _merge_model(builtin: ModelConfig, user: ModelConfig) -> ModelConfig:
     """Merge user model config with builtin model config.
 
-    Strategy: user values take precedence if explicitly set (not default).
-    This allows users to override specific fields (e.g., disabled=true)
+    Strategy: user values take precedence if explicitly set (not unset).
+    This allows users to override specific fields (e.g., disabled=true/false)
     without losing other builtin settings (e.g., model_id, max_tokens).
     """
     merged_data = builtin.model_dump()
-    user_data = user.model_dump(exclude_defaults=True, exclude={"model_name"})
+    user_data = user.model_dump(exclude_unset=True, exclude={"model_name"})
     for key, value in user_data.items():
         if value is not None:
             merged_data[key] = value
@@ -485,10 +508,9 @@ def _merge_provider(builtin: ProviderConfig, user: UserProviderConfig) -> Provid
             # New model from user
             merged_models[m.model_name] = m
 
-    # For other fields, use user values if explicitly set, otherwise use builtin
-    # We check if user explicitly provided a value by comparing to defaults
+    # For other fields, use user values if explicitly set, otherwise use builtin.
     merged_data = builtin.model_dump()
-    user_data = user.model_dump(exclude_defaults=True, exclude={"model_list"})
+    user_data = user.model_dump(exclude_unset=True, exclude={"model_list"})
 
     # Update with user's explicit settings
     for key, value in user_data.items():

klaude_code/config/sub_agent_model_helper.py

@@ -5,13 +5,12 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
+from klaude_code.protocol import tools
 from klaude_code.protocol.sub_agent import (
     AVAILABILITY_IMAGE_MODEL,
     SubAgentProfile,
     get_sub_agent_profile,
-    get_sub_agent_profile_by_tool,
     iter_sub_agent_profiles,
-    sub_agent_tool_names,
 )
 from klaude_code.protocol.tools import SubAgentType
 
@@ -30,7 +29,7 @@ class SubAgentModelInfo:
     # Effective model name used by this sub-agent.
     # - When configured_model is set: equals configured_model.
     # - When requirement-based default applies (e.g. ImageGen): resolved model.
-    # - When inheriting from main agent: None.
+    # - When inheriting from defaults: resolved model name.
     effective_model: str | None
 
 
@@ -106,10 +105,11 @@ class SubAgentModelHelper:
     ) -> EmptySubAgentModelBehavior:
         """Describe what happens when a sub-agent model is not configured.
 
-        Most sub-agents default to inheriting the main model.
+        Most sub-agents default to the Task model if configured, otherwise
+        they inherit the main model.
 
         Sub-agents with an availability requirement (e.g. ImageGen) do NOT
-        inherit from the main model; instead they auto-resolve a suitable model
+        inherit from Task/main; instead they auto-resolve a suitable model
         (currently: the first available image model).
         """
 
@@ -117,9 +117,11 @@ class SubAgentModelHelper:
 
         requirement = profile.availability_requirement
         if requirement is None:
+            task_model = self._config.sub_agent_models.get(tools.TASK)
+            resolved = task_model or main_model_name
             return EmptySubAgentModelBehavior(
-                description=f"inherit from main agent: {main_model_name}",
-                resolved_model_name=main_model_name,
+                description=f"use default behavior: {resolved}",
+                resolved_model_name=resolved,
             )
 
         resolved = self.resolve_model_for_requirement(requirement)
@@ -154,13 +156,15 @@ class SubAgentModelHelper:
         For sub-agents without explicit config, resolves model based on availability_requirement.
         """
         result: list[SubAgentModelInfo] = []
-        for profile in iter_sub_agent_profiles(enabled_only=True):
+        for profile in iter_sub_agent_profiles():
             if not self.check_availability_requirement(profile.availability_requirement):
                 continue
             configured_model = self._config.sub_agent_models.get(profile.name)
             effective_model = configured_model
             if not effective_model and profile.availability_requirement:
                 effective_model = self.resolve_model_for_requirement(profile.availability_requirement)
+            if not effective_model and profile.availability_requirement is None:
+                effective_model = self._config.sub_agent_models.get(tools.TASK) or self._config.main_model
             result.append(
                 SubAgentModelInfo(
                     profile=profile,
@@ -189,11 +193,9 @@ class SubAgentModelHelper:
 
     def get_enabled_sub_agent_tool_names(self) -> list[str]:
         """Return sub-agent tool names that should be added to main agent's tool list."""
-        result: list[str] = []
-        for name in sub_agent_tool_names(enabled_only=True):
-            profile = get_sub_agent_profile_by_tool(name)
-            if profile is not None and self.check_availability_requirement(profile.availability_requirement):
-                result.append(name)
+        result: list[str] = [tools.TASK]
+        if self.check_availability_requirement(AVAILABILITY_IMAGE_MODEL):
+            result.append(tools.IMAGE_GEN)
         return result
 
     def build_sub_agent_client_configs(self) -> dict[SubAgentType, str]:
@@ -205,4 +207,7 @@ class SubAgentModelHelper:
                 model_name = self.resolve_model_for_requirement(profile.availability_requirement)
             if model_name:
                 result[profile.name] = model_name
+        task_model = self._config.sub_agent_models.get(tools.TASK)
+        if task_model:
+            result.setdefault(tools.TASK, task_model)
         return result

klaude_code/config/thinking.py

@@ -62,14 +62,6 @@ def _is_gemini_flash_model(model_name: str | None) -> bool:
     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):

klaude_code/const.py

@@ -141,7 +141,7 @@ MIN_HIDDEN_LINES_FOR_INDICATOR = 5  # Minimum hidden lines before showing trunca
 SUB_AGENT_RESULT_MAX_LINES = 10  # Maximum lines for sub-agent result display
 TRUNCATE_HEAD_MAX_LINES = 2  # Maximum lines for sub-agent error display
 BASH_OUTPUT_PANEL_THRESHOLD = 10  # Bash output line threshold for CodePanel display
-BASH_MULTILINE_STRING_TRUNCATE_MAX_LINES = 2  # Max lines shown for heredoc / multiline string tokens in bash tool calls
+BASH_MULTILINE_STRING_TRUNCATE_MAX_LINES = 4  # Max lines shown for heredoc / multiline string tokens in bash tool calls
 URL_TRUNCATE_MAX_LENGTH = 400  # Maximum length for URL truncation in display
 QUERY_DISPLAY_TRUNCATE_LENGTH = 80  # Maximum length for search query display
 NOTIFY_COMPACT_LIMIT = 160  # Maximum length for notification body text

klaude_code/core/agent_profile.py

@@ -12,12 +12,10 @@ from typing import TYPE_CHECKING, Any, Protocol
 if TYPE_CHECKING:
     from klaude_code.config.config import Config
 
-from klaude_code.auth.codex.exceptions import CodexUnsupportedModelError
 from klaude_code.config.sub_agent_model_helper import SubAgentModelHelper
 from klaude_code.core.reminders import (
     at_file_reader_reminder,
     empty_todo_reminder,
-    file_changed_externally_reminder,
     image_reminder,
     last_path_memory_reminder,
     memory_reminder,
@@ -28,7 +26,7 @@ from klaude_code.core.tool.report_back_tool import ReportBackTool
 from klaude_code.core.tool.tool_registry import get_tool_schemas
 from klaude_code.llm import LLMClientABC
 from klaude_code.protocol import llm_param, message, tools
-from klaude_code.protocol.sub_agent import get_sub_agent_profile
+from klaude_code.protocol.sub_agent import AVAILABILITY_IMAGE_MODEL, get_sub_agent_profile
 from klaude_code.session import Session
 
 type Reminder = Callable[[Session], Awaitable[message.DeveloperMessage | None]]
@@ -54,12 +52,6 @@ COMMAND_DESCRIPTIONS: dict[str, str] = {
 }
 
 
-# Prompts for codex_oauth protocol - must be used exactly as-is without any additions.
-CODEX_OAUTH_PROMPTS: dict[str, str] = {
-    "gpt-5.2-codex": "prompts/prompt-codex-gpt-5-2-codex.md",
-    "gpt-5.2": "prompts/prompt-codex-gpt-5-2.md",
-}
-
 # Prompt for antigravity protocol - used exactly as-is without any additions.
 ANTIGRAVITY_PROMPT_PATH = "prompts/prompt-antigravity.md"
 
@@ -73,20 +65,6 @@ Only the content passed to `report_back` will be returned to user.\
 """
 
 
-SUB_AGENT_COMMON_PROMPT_FOR_MAIN_AGENT = """\
-
-# Sub-agent capabilities
-You have sub-agents (e.g. Task, Explore, WebAgent, ImageGen) with structured output and resume capabilites:
-- Agents can be provided with an `output_format` (JSON Schema) parameter for structured output
--   Example: `output_format={"type": "object", "properties": {"files": {"type": "array", "items": {"type": "string"}, "description": "List of file paths that match the search criteria, e.g. ['src/main.py', 'src/utils/helper.py']"}}, "required": ["files"]}`
-- Agents can be resumed using the `resume` parameter by passing the agent ID from a previous invocation. \
-When resumed, the agent continues with its full previous context preserved. \
-When NOT resuming, each invocation starts fresh and you should provide a detailed task description with all necessary context.
-- When the agent is done, it will return a single message back to you along with its agent ID. \
-You can use this ID to resume the agent later if needed for follow-up work.
-"""
-
-
 @cache
 def _load_prompt_by_path(prompt_path: str) -> str:
     """Load and cache prompt content from a file path relative to core package."""
@@ -144,19 +122,6 @@ def _build_env_info(model_name: str) -> str:
     return "\n".join(env_lines)
 
 
-def _has_sub_agents(config: Config | None) -> bool:
-    """Check if there are any sub-agent tools available for the main agent."""
-    if config is not None:
-        from klaude_code.config.sub_agent_model_helper import SubAgentModelHelper
-
-        helper = SubAgentModelHelper(config)
-        return bool(helper.get_enabled_sub_agent_tool_names())
-
-    from klaude_code.protocol.sub_agent import sub_agent_tool_names
-
-    return bool(sub_agent_tool_names(enabled_only=True))
-
-
 def load_system_prompt(
     model_name: str,
     protocol: llm_param.LLMClientProtocol,
@@ -165,12 +130,11 @@ def load_system_prompt(
 ) -> str:
     """Get system prompt content for the given model and sub-agent type."""
 
-    # For codex_oauth protocol, use exact prompts without any additions.
+    # For codex_oauth protocol, use dynamic prompts from GitHub (no additions).
     if protocol == llm_param.LLMClientProtocol.CODEX_OAUTH:
-        for model_key, prompt_path in CODEX_OAUTH_PROMPTS.items():
-            if model_key in model_name:
-                return _load_prompt_by_path(prompt_path)
-        raise CodexUnsupportedModelError(f"codex_oauth protocol does not support model: {model_name}")
+        from klaude_code.llm.codex.prompt_sync import get_codex_instructions
+
+        return get_codex_instructions(model_name)
 
     # For antigravity protocol, use exact prompt without any additions.
     if protocol == llm_param.LLMClientProtocol.ANTIGRAVITY:
@@ -183,18 +147,13 @@ def load_system_prompt(
         base_prompt = _load_prompt_by_model(model_name)
 
     skills_prompt = ""
-    sub_agent_prompt = ""
     if sub_agent_type is None:
         # Skills are progressive-disclosure: keep only metadata in the system prompt.
         from klaude_code.skill.manager import format_available_skills_for_system_prompt
 
         skills_prompt = format_available_skills_for_system_prompt()
 
-        # Add sub-agent resume instructions if there are sub-agent tools available.
-        if _has_sub_agents(config):
-            sub_agent_prompt = "\n" + SUB_AGENT_COMMON_PROMPT_FOR_MAIN_AGENT
-
-    return base_prompt + _build_env_info(model_name) + skills_prompt + sub_agent_prompt
+    return base_prompt + _build_env_info(model_name) + skills_prompt
 
 
 def load_agent_tools(
@@ -222,13 +181,13 @@ def load_agent_tools(
     else:
         tool_names = [tools.BASH, tools.READ, tools.EDIT, tools.WRITE, tools.TODO_WRITE]
 
+    tool_names.append(tools.TASK)
     if config is not None:
         helper = SubAgentModelHelper(config)
-        tool_names.extend(helper.get_enabled_sub_agent_tool_names())
+        if helper.check_availability_requirement(AVAILABILITY_IMAGE_MODEL):
+            tool_names.append(tools.IMAGE_GEN)
     else:
-        from klaude_code.protocol.sub_agent import sub_agent_tool_names
-
-        tool_names.extend(sub_agent_tool_names(enabled_only=True))
+        tool_names.append(tools.IMAGE_GEN)
 
     tool_names.extend([tools.MERMAID])
     # tool_names.extend([tools.MEMORY])
@@ -258,7 +217,6 @@ def load_agent_reminders(
             memory_reminder,
             at_file_reader_reminder,
             last_path_memory_reminder,
-            file_changed_externally_reminder,
             image_reminder,
             skill_reminder,
         ]

klaude_code/core/compaction/overflow.py

@@ -24,7 +24,3 @@ def is_context_overflow(error_message: str | None) -> bool:
     if _STATUS_CODE_PATTERN.search(error_message):
         return True
     return any(pattern.search(error_message) for pattern in _OVERFLOW_PATTERNS)
-
-
-def get_overflow_patterns() -> list[re.Pattern[str]]:
-    return list(_OVERFLOW_PATTERNS)

klaude_code/core/executor.py

@@ -676,6 +676,39 @@ class ExecutorContext:
             )
         )
 
+    async def handle_change_compact_model(self, operation: op.ChangeCompactModelOperation) -> None:
+        """Handle a change compact model operation."""
+        agent = await self._agent_runtime.ensure_agent(operation.session_id)
+        config = load_config()
+
+        model_name = operation.model_name
+
+        if model_name is None:
+            # Clear explicit override and use main client for compaction
+            self.llm_clients.compact = None
+            agent.compact_llm_client = None
+            display_model = "(inherit from main agent)"
+        else:
+            # Create new client for compaction
+            llm_config = config.get_model_config(model_name)
+            new_client = create_llm_client(llm_config)
+            self.llm_clients.compact = new_client
+            agent.compact_llm_client = new_client
+            display_model = new_client.model_name
+
+        if operation.save_as_default:
+            config.compact_model = model_name
+            await config.save()
+
+        saved_note = " (saved in ~/.klaude/klaude-config.yaml)" if operation.save_as_default else ""
+        await self.emit_event(
+            events.CommandOutputEvent(
+                session_id=agent.session.id,
+                command_name=commands.CommandName.SUB_AGENT_MODEL,
+                content=f"Compact model: {display_model}{saved_note}",
+            )
+        )
+
     async def handle_clear_session(self, operation: op.ClearSessionOperation) -> None:
         await self._agent_runtime.clear_session(operation.session_id)
 
@@ -763,11 +796,6 @@ class ExecutorContext:
             return None
         return active.task
 
-    def has_active_task(self, submission_id: str) -> bool:
-        """Return True if a task is registered for the submission id."""
-
-        return self.task_manager.get(submission_id) is not None
-
 
 class Executor:
     """

klaude_code/core/manager/llm_clients.py

@@ -6,6 +6,7 @@ from dataclasses import dataclass
 from dataclasses import field as dataclass_field
 
 from klaude_code.llm.client import LLMClientABC
+from klaude_code.protocol import tools
 from klaude_code.protocol.tools import SubAgentType
 
 
@@ -26,7 +27,14 @@ class LLMClients:
 
         if sub_agent_type is None:
             return self.main
-        return self.sub_clients.get(sub_agent_type) or self.main
+        client = self.sub_clients.get(sub_agent_type)
+        if client is not None:
+            return client
+        if sub_agent_type != tools.TASK:
+            fallback = self.sub_clients.get(tools.TASK)
+            if fallback is not None:
+                return fallback
+        return self.main
 
     def get_compact_client(self) -> LLMClientABC:
         """Return compact client if configured, otherwise main client."""

klaude_code/core/prompts/prompt-claude-code.md

@@ -72,16 +72,16 @@ The user will primarily request you perform software engineering tasks. This inc
 - Tool results and user messages may include <system-reminder> tags. <system-reminder> tags contain useful information and reminders. They are automatically added by the system, and bear no direct relation to the specific tool results or user messages in which they appear.
 
 ## Tool usage policy
-- When doing file search, prefer to use the Explore tool in order to reduce context usage.
+- When doing file search, prefer to use the Task tool in order to reduce context usage.
 - You can call multiple tools in a single response. If you intend to call multiple tools and there are no dependencies between them, make all independent tool calls in parallel. Maximize use of parallel tool calls where possible to increase efficiency. However, if some tool calls depend on previous calls to inform dependent values, do NOT call these tools in parallel and instead call them sequentially. For instance, if one operation must complete before another starts, run these operations sequentially instead. Never use placeholders or guess missing parameters in tool calls.
 - If the user specifies that they want you to run tools "in parallel", you MUST send a single message with multiple tool use content blocks. For example, if you need to launch multiple agents in parallel, send a single message with multiple Task tool calls.
 - Use specialized tools instead of bash commands when possible, as this provides a better user experience. For file operations, use dedicated tools: Read for reading files instead of cat/head/tail, Edit for editing instead of sed/awk. NEVER use bash echo or other command-line tools to communicate thoughts, explanations, or instructions to the user. Output all communication directly in your response text instead.
-- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the Explore tool instead of running search commands directly.
+- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the Task tool with subagent_type=Explore instead of running search commands directly.
 <example>
 user: Where are errors from the client handled?
-assistant: [Uses the Explore tool to find the files that handle client errors instead of using Glob or Grep directly]
+assistant: [Uses the Task tool with subagent_type=Explore to find the files that handle client errors instead of using Glob or Grep directly]
 </example>
 <example>
 user: What is the codebase structure?
-assistant: [Uses the Explore tool]
+assistant: [Uses the Task tool with subagent_type=Explore]
 </example>

klaude_code/core/reminders.py

@@ -21,20 +21,6 @@ AT_FILE_PATTERN = re.compile(r'(?:(?<!\S)|(?<=\u2192))@("(?P<quoted>[^\"]+)"|(?P
 SKILL_PATTERN = re.compile(r"(?:^|\s)[$¥](?P<skill>\S+)")
 
 
-def get_last_new_user_input(session: Session) -> str | None:
-    """Get last user input & developer message (CLAUDE.md) from conversation history. if there's a tool result after user input, return None"""
-    result: list[str] = []
-    for item in reversed(session.conversation_history):
-        if isinstance(item, message.ToolResultMessage):
-            return None
-        if isinstance(item, message.UserMessage):
-            result.append(message.join_text_parts(item.parts))
-            break
-        if isinstance(item, message.DeveloperMessage):
-            result.append(message.join_text_parts(item.parts))
-    return "\n\n".join(result)
-
-
 @dataclass
 class AtPatternSource:
     """Represents an @ pattern with its source file (if from a memory file)."""
@@ -115,6 +101,7 @@ async def _load_at_file_recursive(
     at_ops: list[model.AtFileOp],
     formatted_blocks: list[str],
     collected_images: list[message.ImageURLPart],
+    collected_image_paths: list[str],
     visited: set[str],
     base_dir: Path | None = None,
     mentioned_in: str | None = None,
@@ -150,6 +137,7 @@ Result of calling the {tools.READ} tool:
         at_ops.append(model.AtFileOp(operation="Read", path=path_str, mentioned_in=mentioned_in))
         if images:
             collected_images.extend(images)
+            collected_image_paths.append(path_str)
 
         # Recursively parse @ references from ReadTool output
         output = tool_result.output_text
@@ -163,6 +151,7 @@ Result of calling the {tools.READ} tool:
                         at_ops,
                         formatted_blocks,
                         collected_images,
+                        collected_image_paths,
                         visited,
                         base_dir=path.parent,
                         mentioned_in=path_str,
@@ -193,6 +182,7 @@ async def at_file_reader_reminder(
     at_ops: list[model.AtFileOp] = []
     formatted_blocks: list[str] = []
     collected_images: list[message.ImageURLPart] = []
+    collected_image_paths: list[str] = []
     visited: set[str] = set()
 
     for source in at_pattern_sources:
@@ -202,6 +192,7 @@ async def at_file_reader_reminder(
             at_ops,
             formatted_blocks,
             collected_images,
+            collected_image_paths,
             visited,
             mentioned_in=source.mentioned_in,
         )
@@ -210,12 +201,15 @@ async def at_file_reader_reminder(
         return None
 
     at_files_str = "\n\n".join(formatted_blocks)
+    ui_items: list[model.DeveloperUIItem] = [model.AtFileOpsUIItem(ops=at_ops)]
+    if collected_image_paths:
+        ui_items.append(model.AtFileImagesUIItem(paths=collected_image_paths))
     return message.DeveloperMessage(
         parts=message.parts_from_text_and_images(
             f"""<system-reminder>{at_files_str}\n</system-reminder>""",
             collected_images or None,
         ),
-        ui_extra=model.DeveloperUIExtra(items=[model.AtFileOpsUIItem(ops=at_ops)]),
+        ui_extra=model.DeveloperUIExtra(items=ui_items),
     )
 
 
@@ -410,25 +404,29 @@ class Memory(BaseModel):
     content: str
 
 
-def get_last_user_message_image_count(session: Session) -> int:
-    """Get image count from the last user message in conversation history."""
+def get_last_user_message_image_paths(session: Session) -> list[str]:
+    """Get image file paths from the last user message in conversation history."""
     for item in reversed(session.conversation_history):
         if isinstance(item, message.ToolResultMessage):
-            return 0
+            return []
         if isinstance(item, message.UserMessage):
-            return len([part for part in item.parts if isinstance(part, message.ImageURLPart)])
-    return 0
+            paths: list[str] = []
+            for part in item.parts:
+                if isinstance(part, message.ImageFilePart):
+                    paths.append(part.file_path)
+            return paths
+    return []
 
 
 async def image_reminder(session: Session) -> message.DeveloperMessage | None:
     """Remind agent about images attached by user in the last message."""
-    image_count = get_last_user_message_image_count(session)
-    if image_count == 0:
+    image_paths = get_last_user_message_image_paths(session)
+    if not image_paths:
         return None
 
     return message.DeveloperMessage(
         parts=[],
-        ui_extra=model.DeveloperUIExtra(items=[model.UserImagesUIItem(count=image_count)]),
+        ui_extra=model.DeveloperUIExtra(items=[model.UserImagesUIItem(count=len(image_paths), paths=image_paths)]),
     )
 
 

klaude_code/core/task.py

@@ -179,10 +179,6 @@ class TaskExecutor:
         self._started_at: float = 0.0
         self._metadata_accumulator: MetadataAccumulator | None = None
 
-    @property
-    def current_turn(self) -> TurnExecutor | None:
-        return self._current_turn
-
     def get_partial_metadata(self) -> model.TaskMetadata | None:
         """Get the currently accumulated metadata without finalizing.