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

klaude_code/core/executor.py

@@ -19,7 +19,7 @@ from klaude_code.core.agent import Agent, DefaultModelProfileProvider, ModelProf
 from klaude_code.core.manager import LLMClients, SubAgentManager
 from klaude_code.core.tool import current_run_subtask_callback
 from klaude_code.llm.registry import create_llm_client
-from klaude_code.protocol import commands, events, model, op
+from klaude_code.protocol import commands, events, message, model, op
 from klaude_code.protocol.llm_param import Thinking
 from klaude_code.protocol.op_handler import OperationHandler
 from klaude_code.protocol.sub_agent import SubAgentResult
@@ -193,7 +193,9 @@ class ExecutorContext:
         await self.emit_event(
             events.UserMessageEvent(content=user_input.text, session_id=session_id, images=user_input.images)
         )
-        agent.session.append_history([model.UserMessageItem(content=user_input.text, images=user_input.images)])
+        agent.session.append_history(
+            [message.UserMessage(parts=message.parts_from_text_and_images(user_input.text, user_input.images))]
+        )
 
         await self.handle_run_agent(
             op.RunAgentOperation(
@@ -230,8 +232,8 @@ class ExecutorContext:
 
         if operation.emit_switch_message:
             default_note = " (saved as default)" if operation.save_as_default else ""
-            developer_item = model.DeveloperMessageItem(
-                content=f"Switched to: {llm_config.model}{default_note}",
+            developer_item = message.DeveloperMessage(
+                parts=message.text_parts_from_str(f"Switched to: {llm_config.model}{default_note}"),
                 command_output=model.CommandOutput(command_name=commands.CommandName.MODEL),
             )
             agent.session.append_history([developer_item])
@@ -275,8 +277,8 @@ class ExecutorContext:
         new_status = _format_thinking_for_display(config.thinking)
 
         if operation.emit_switch_message:
-            developer_item = model.DeveloperMessageItem(
-                content=f"Thinking changed: {current} -> {new_status}",
+            developer_item = message.DeveloperMessage(
+                parts=message.text_parts_from_str(f"Thinking changed: {current} -> {new_status}"),
                 command_output=model.CommandOutput(command_name=commands.CommandName.THINKING),
             )
             agent.session.append_history([developer_item])
@@ -293,11 +295,17 @@ class ExecutorContext:
         new_session.model_thinking = agent.session.model_thinking
         agent.session = new_session
 
-        developer_item = model.DeveloperMessageItem(
-            content="started new conversation",
+        developer_item = message.DeveloperMessage(
+            parts=message.text_parts_from_str("started new conversation"),
             command_output=model.CommandOutput(command_name=commands.CommandName.CLEAR),
         )
         await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+        await self.emit_event(
+            events.WelcomeEvent(
+                work_dir=str(agent.session.work_dir),
+                llm_config=self.llm_clients.main.get_llm_config(),
+            )
+        )
 
     async def handle_resume_session(self, operation: op.ResumeSessionOperation) -> None:
         target_session = Session.load(operation.target_session_id)
@@ -338,8 +346,8 @@ class ExecutorContext:
             await asyncio.to_thread(output_path.parent.mkdir, parents=True, exist_ok=True)
             await asyncio.to_thread(output_path.write_text, html_doc, "utf-8")
             await asyncio.to_thread(self._open_file, output_path)
-            developer_item = model.DeveloperMessageItem(
-                content=f"Session exported and opened: {output_path}",
+            developer_item = message.DeveloperMessage(
+                parts=message.text_parts_from_str(f"Session exported and opened: {output_path}"),
                 command_output=model.CommandOutput(command_name=commands.CommandName.EXPORT),
             )
             agent.session.append_history([developer_item])
@@ -347,8 +355,8 @@ class ExecutorContext:
         except Exception as exc:  # pragma: no cover
             import traceback
 
-            developer_item = model.DeveloperMessageItem(
-                content=f"Failed to export session: {exc}\n{traceback.format_exc()}",
+            developer_item = message.DeveloperMessage(
+                parts=message.text_parts_from_str(f"Failed to export session: {exc}\n{traceback.format_exc()}"),
                 command_output=model.CommandOutput(command_name=commands.CommandName.EXPORT, is_error=True),
             )
             agent.session.append_history([developer_item])
@@ -357,7 +365,7 @@ class ExecutorContext:
     async def _run_agent_task(
         self,
         agent: Agent,
-        user_input: model.UserInputPayload,
+        user_input: message.UserInputPayload,
         task_id: str,
         session_id: str,
     ) -> None:

klaude_code/core/manager/sub_agent_manager.py

@@ -8,11 +8,13 @@ their events back to the shared event queue.
 from __future__ import annotations
 
 import asyncio
+import json
 
 from klaude_code.core.agent import Agent, AgentProfile, ModelProfileProvider
 from klaude_code.core.manager.llm_clients import LLMClients
 from klaude_code.core.tool import ReportBackTool
-from klaude_code.protocol import events, model
+from klaude_code.core.tool.tool_context import record_sub_agent_session_id
+from klaude_code.protocol import events, message, model
 from klaude_code.protocol.sub_agent import SubAgentResult
 from klaude_code.session.session import Session
 from klaude_code.trace import DebugType, log_debug
@@ -39,10 +41,60 @@ class SubAgentManager:
     async def run_sub_agent(self, parent_agent: Agent, state: model.SubAgentState) -> SubAgentResult:
         """Run a nested sub-agent task and return its result."""
 
-        # Create a child session under the same workdir
         parent_session = parent_agent.session
-        child_session = Session(work_dir=parent_session.work_dir)
-        child_session.sub_agent_state = state
+        resume_session_id = state.resume
+
+        def _append_agent_id(task_result: str, session_id: str) -> str:
+            trimmed = (task_result or "").rstrip()
+            footer = f"agentId: {session_id} (for resuming to continue this agent's work if needed)"
+            if trimmed.strip():
+                return f"{trimmed}\n\n{footer}"
+            return footer
+
+        if resume_session_id:
+            try:
+                child_session = Session.load(resume_session_id)
+            except (OSError, ValueError, json.JSONDecodeError) as exc:
+                return SubAgentResult(
+                    task_result=f"Failed to resume sub-agent session '{resume_session_id}': {exc}",
+                    session_id="",
+                    error=True,
+                )
+
+            if child_session.sub_agent_state is None:
+                return SubAgentResult(
+                    task_result=(f"Invalid resume id '{resume_session_id}': target session is not a sub-agent session"),
+                    session_id="",
+                    error=True,
+                )
+            if child_session.sub_agent_state.sub_agent_type != state.sub_agent_type:
+                return SubAgentResult(
+                    task_result=(
+                        "Invalid resume id: sub-agent type mismatch. "
+                        f"Expected '{state.sub_agent_type}', got '{child_session.sub_agent_state.sub_agent_type}'."
+                    ),
+                    session_id="",
+                    error=True,
+                )
+
+            # Expose the session id immediately so ToolExecutor.cancel() can attach
+            # it to the synthesized cancellation ToolResult.
+            record_sub_agent_session_id(child_session.id)
+
+            # Update persisted sub-agent state to reflect the current invocation.
+            child_session.sub_agent_state.sub_agent_desc = state.sub_agent_desc
+            child_session.sub_agent_state.sub_agent_prompt = state.sub_agent_prompt
+            child_session.sub_agent_state.resume = resume_session_id
+            child_session.sub_agent_state.output_schema = state.output_schema
+            child_session.sub_agent_state.generation = state.generation
+        else:
+            # Create a new child session under the same workdir
+            child_session = Session(work_dir=parent_session.work_dir)
+            child_session.sub_agent_state = state
+
+            # Expose the new session id immediately so ToolExecutor.cancel() can attach
+            # it to the synthesized cancellation ToolResult.
+            record_sub_agent_session_id(child_session.id)
 
         child_profile = self._model_profile_provider.build_profile(
             self._llm_clients.get_client(state.sub_agent_type),
@@ -79,18 +131,30 @@ Only the content passed to `report_back` will be returned to user.\
             # Not emit the subtask's user input since task tool call is already rendered
             result: str = ""
             task_metadata: model.TaskMetadata | None = None
-            sub_agent_input = model.UserInputPayload(text=state.sub_agent_prompt, images=None)
+            sub_agent_input = message.UserInputPayload(text=state.sub_agent_prompt, images=None)
             child_session.append_history(
-                [model.UserMessageItem(content=sub_agent_input.text, images=sub_agent_input.images)]
+                [
+                    message.UserMessage(
+                        parts=message.parts_from_text_and_images(sub_agent_input.text, sub_agent_input.images)
+                    )
+                ]
             )
             async for event in child_agent.run_task(sub_agent_input):
                 # Capture TaskFinishEvent content for return
                 if isinstance(event, events.TaskFinishEvent):
-                    result = event.task_result
+                    result = _append_agent_id(event.task_result, child_session.id)
+                    event = events.TaskFinishEvent(
+                        session_id=event.session_id,
+                        task_result=result,
+                        has_structured_output=event.has_structured_output,
+                    )
                 # Capture TaskMetadataEvent for metadata propagation
                 elif isinstance(event, events.TaskMetadataEvent):
                     task_metadata = event.metadata.main_agent
                 await self.emit_event(event)
+
+            # Ensure the sub-agent session is persisted before returning its id for resume.
+            await child_session.wait_for_flush()
             return SubAgentResult(
                 task_result=result,
                 session_id=child_session.id,

klaude_code/core/prompt.py

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

klaude_code/core/prompts/prompt-sub-agent-image-gen.md

@@ -0,0 +1 @@
+You are an image generation agent. Generate images based on the user's prompt.

klaude_code/core/prompts/prompt-sub-agent-web.md

@@ -1,5 +1,11 @@
 You are a web research subagent that searches and fetches web content to provide up-to-date information as part of team.
 
+## Core Principles
+
+- **Never invent facts**. If you cannot verify something, say so clearly and explain what you did find.
+- If evidence is thin, keep searching rather than guessing.
+- When sources conflict, actively resolve contradictions by finding additional authoritative sources.
+
 ## Available Tools
 
 **WebSearch**: Search the web via DuckDuckGo
@@ -32,6 +38,19 @@ Balance efficiency with thoroughness. For open-ended questions (e.g., "recommend
 - Follow relevant links on pages with WebFetch
 - If truncated results are saved to local files, use grep/read to explore
 
+### Research Strategy
+
+- Start with multiple targeted searches. Use parallel searches when helpful. Never rely on a single query.
+- Begin broad enough to capture the main answer, then add targeted follow-ups to fill gaps or confirm claims.
+- If the topic is time-sensitive, explicitly check for recent updates.
+- If the query implies comparisons or recommendations, gather enough coverage to make tradeoffs clear.
+- Keep iterating until additional searching is unlikely to materially change the answer.
+
+### Handling Ambiguity
+
+- Do not ask clarifying questions - you cannot interact with the user.
+- If the query is ambiguous, state your interpretation plainly, then comprehensively cover all plausible intents.
+
 ## Response Guidelines
 
 - Only your last message is returned to the main agent
@@ -40,7 +59,14 @@ Balance efficiency with thoroughness. For open-ended questions (e.g., "recommend
 - Include the file path from `<file_saved>` so the main agent can access full content if needed
 - Lead with the most recent info for evolving topics
 - Favor original sources (company blogs, papers, gov sites) over aggregators
-- Note conflicting sources when they exist
+- When sources conflict, explain the discrepancy and which source is more authoritative
+
+### Before Finalizing
+
+Stop only when all are true:
+1. You answered the query and every subpart
+2. You found sufficient sources for core claims
+3. You resolved any contradictions between sources
 
 ## Sources (REQUIRED)
 

klaude_code/core/reminders.py

@@ -7,14 +7,14 @@ from pathlib import Path
 
 from pydantic import BaseModel
 
-from klaude_code import const
+from klaude_code.const import MEMORY_FILE_NAMES, REMINDER_COOLDOWN_TURNS, TODO_REMINDER_TOOL_CALL_THRESHOLD
 from klaude_code.core.tool import BashTool, ReadTool, reset_tool_context, set_tool_context_from_session
 from klaude_code.core.tool.file._utils import hash_text_sha256
-from klaude_code.protocol import model, tools
+from klaude_code.protocol import message, model, tools
 from klaude_code.session import Session
 from klaude_code.skill import get_skill
 
-type Reminder = Callable[[Session], Awaitable[model.DeveloperMessageItem | None]]
+type Reminder = Callable[[Session], Awaitable[message.DeveloperMessage | None]]
 
 
 # Match @ preceded by whitespace, start of line, or → (ReadTool line number arrow)
@@ -28,13 +28,13 @@ 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, model.ToolResultItem):
+        if isinstance(item, message.ToolResultMessage):
             return None
-        if isinstance(item, model.UserMessageItem):
-            result.append(item.content or "")
+        if isinstance(item, message.UserMessage):
+            result.append(message.join_text_parts(item.parts))
             break
-        if isinstance(item, model.DeveloperMessageItem):
-            result.append(item.content or "")
+        if isinstance(item, message.DeveloperMessage):
+            result.append(message.join_text_parts(item.parts))
     return "\n\n".join(result)
 
 
@@ -62,16 +62,16 @@ def get_at_patterns_with_source(session: Session) -> list[AtPatternSource]:
     patterns: list[AtPatternSource] = []
 
     for item in reversed(session.conversation_history):
-        if isinstance(item, model.ToolResultItem):
+        if isinstance(item, message.ToolResultMessage):
             break
 
-        if isinstance(item, model.UserMessageItem):
-            content = item.content or ""
+        if isinstance(item, message.UserMessage):
+            content = message.join_text_parts(item.parts)
             for path_str in _extract_at_patterns(content):
                 patterns.append(AtPatternSource(pattern=path_str, mentioned_in=None))
             break
 
-        if isinstance(item, model.DeveloperMessageItem) and item.memory_mentioned:
+        if isinstance(item, message.DeveloperMessage) and item.memory_mentioned:
             for memory_path, mentioned_patterns in item.memory_mentioned.items():
                 for pattern in mentioned_patterns:
                     patterns.append(AtPatternSource(pattern=pattern, mentioned_in=memory_path))
@@ -81,10 +81,10 @@ def get_at_patterns_with_source(session: Session) -> list[AtPatternSource]:
 def get_skill_from_user_input(session: Session) -> str | None:
     """Get $skill reference from the first line of last user input."""
     for item in reversed(session.conversation_history):
-        if isinstance(item, model.ToolResultItem):
+        if isinstance(item, message.ToolResultMessage):
             return None
-        if isinstance(item, model.UserMessageItem):
-            content = item.content or ""
+        if isinstance(item, message.UserMessage):
+            content = message.join_text_parts(item.parts)
             first_line = content.split("\n", 1)[0]
             m = SKILL_PATTERN.match(first_line)
             if m:
@@ -114,7 +114,7 @@ async def _load_at_file_recursive(
     session: Session,
     pattern: str,
     at_files: dict[str, model.AtPatternParseResult],
-    collected_images: list[model.ImageURLPart],
+    collected_images: list[message.ImageURLPart],
     visited: set[str],
     base_dir: Path | None = None,
     mentioned_in: str | None = None,
@@ -134,20 +134,20 @@ async def _load_at_file_recursive(
                 return
             args = ReadTool.ReadArguments(file_path=path_str)
             tool_result = await ReadTool.call_with_args(args)
+            images = [part for part in tool_result.parts if isinstance(part, message.ImageURLPart)]
             at_files[path_str] = model.AtPatternParseResult(
                 path=path_str,
                 tool_name=tools.READ,
-                result=tool_result.output or "",
+                result=tool_result.output_text,
                 tool_args=args.model_dump_json(exclude_none=True),
                 operation="Read",
-                images=tool_result.images,
                 mentioned_in=mentioned_in,
             )
-            if tool_result.images:
-                collected_images.extend(tool_result.images)
+            if images:
+                collected_images.extend(images)
 
             # Recursively parse @ references from ReadTool output
-            output = tool_result.output or ""
+            output = tool_result.output_text
             if "@" in output:
                 for match in AT_FILE_PATTERN.finditer(output):
                     nested = match.group("quoted") or match.group("plain")
@@ -168,7 +168,7 @@ async def _load_at_file_recursive(
             at_files[path_str] = model.AtPatternParseResult(
                 path=path_str + "/",
                 tool_name=tools.BASH,
-                result=tool_result.output or "",
+                result=tool_result.output_text,
                 tool_args=args.model_dump_json(exclude_none=True),
                 operation="List",
             )
@@ -178,14 +178,14 @@ async def _load_at_file_recursive(
 
 async def at_file_reader_reminder(
     session: Session,
-) -> model.DeveloperMessageItem | None:
+) -> message.DeveloperMessage | None:
     """Parse @foo/bar to read, with recursive loading of nested @ references"""
     at_pattern_sources = get_at_patterns_with_source(session)
     if not at_pattern_sources:
         return None
 
     at_files: dict[str, model.AtPatternParseResult] = {}  # path -> content
-    collected_images: list[model.ImageURLPart] = []
+    collected_images: list[message.ImageURLPart] = []
     visited: set[str] = set()
 
     for source in at_pattern_sources:
@@ -210,14 +210,16 @@ Result of calling the {result.tool_name} tool:
             for result in at_files.values()
         ]
     )
-    return model.DeveloperMessageItem(
-        content=f"""<system-reminder>{at_files_str}\n</system-reminder>""",
+    return message.DeveloperMessage(
+        parts=message.parts_from_text_and_images(
+            f"""<system-reminder>{at_files_str}\n</system-reminder>""",
+            collected_images or None,
+        ),
         at_files=list(at_files.values()),
-        images=collected_images or None,
     )
 
 
-async def empty_todo_reminder(session: Session) -> model.DeveloperMessageItem | None:
+async def empty_todo_reminder(session: Session) -> message.DeveloperMessage | None:
     """Remind agent to use TodoWrite tool when todos are empty/all completed.
 
     Behavior:
@@ -233,9 +235,11 @@ async def empty_todo_reminder(session: Session) -> model.DeveloperMessageItem |
         return None
 
     if session.need_todo_empty_cooldown_counter == 0:
-        session.need_todo_empty_cooldown_counter = 3
-        return model.DeveloperMessageItem(
-            content="""<system-reminder>This is a reminder that your todo list is currently empty. DO NOT mention this to the user explicitly because they are already aware. If you are working on tasks that would benefit from a todo list please use the TodoWrite tool to create one. If not, please feel free to ignore. Again do not mention this message to the user.</system-reminder>"""
+        session.need_todo_empty_cooldown_counter = REMINDER_COOLDOWN_TURNS
+        return message.DeveloperMessage(
+            parts=message.text_parts_from_str(
+                "<system-reminder>This is a reminder that your todo list is currently empty. DO NOT mention this to the user explicitly because they are already aware. If you are working on tasks that would benefit from a todo list please use the TodoWrite tool to create one. If not, please feel free to ignore. Again do not mention this message to the user.</system-reminder>"
+            )
         )
 
     if session.need_todo_empty_cooldown_counter > 0:
@@ -245,7 +249,7 @@ async def empty_todo_reminder(session: Session) -> model.DeveloperMessageItem |
 
 async def todo_not_used_recently_reminder(
     session: Session,
-) -> model.DeveloperMessageItem | None:
+) -> message.DeveloperMessage | None:
     """Remind agent to use TodoWrite tool if it hasn't been used recently (>=10 other tool calls), with cooldown.
 
     Cooldown behavior:
@@ -264,28 +268,37 @@ async def todo_not_used_recently_reminder(
     # Count non-todo tool calls since the last TodoWrite
     other_tool_call_count_before_last_todo = 0
     for item in reversed(session.conversation_history):
-        if isinstance(item, model.ToolCallItem):
-            if item.name in (tools.TODO_WRITE, tools.UPDATE_PLAN):
+        if not isinstance(item, message.AssistantMessage):
+            continue
+        for part in reversed(item.parts):
+            if not isinstance(part, message.ToolCallPart):
+                continue
+            if part.tool_name in (tools.TODO_WRITE, tools.UPDATE_PLAN):
+                other_tool_call_count_before_last_todo = 0
                 break
             other_tool_call_count_before_last_todo += 1
-            if other_tool_call_count_before_last_todo >= const.TODO_REMINDER_TOOL_CALL_THRESHOLD:
+            if other_tool_call_count_before_last_todo >= TODO_REMINDER_TOOL_CALL_THRESHOLD:
                 break
+        if other_tool_call_count_before_last_todo == 0:
+            break
 
-    not_used_recently = other_tool_call_count_before_last_todo >= const.TODO_REMINDER_TOOL_CALL_THRESHOLD
+    not_used_recently = other_tool_call_count_before_last_todo >= TODO_REMINDER_TOOL_CALL_THRESHOLD
 
     if not not_used_recently:
         return None
 
     if session.need_todo_not_used_cooldown_counter == 0:
-        session.need_todo_not_used_cooldown_counter = 3
-        return model.DeveloperMessageItem(
-            content=f"""<system-reminder>
+        session.need_todo_not_used_cooldown_counter = REMINDER_COOLDOWN_TURNS
+        return message.DeveloperMessage(
+            parts=message.text_parts_from_str(
+                f"""<system-reminder>
 The TodoWrite tool hasn't been used recently. If you're working on tasks that would benefit from tracking progress, consider using the TodoWrite tool to track progress. Also consider cleaning up the todo list if has become stale and no longer matches what you are working on. Only use it if it's relevant to the current work. This is just a gentle reminder - ignore if not applicable.
 
 
 Here are the existing contents of your todo list:
 
-{model.todo_list_str(session.todos)}</system-reminder>""",
+{model.todo_list_str(session.todos)}</system-reminder>"""
+            ),
             todo_use=True,
         )
 
@@ -296,10 +309,10 @@ Here are the existing contents of your todo list:
 
 async def file_changed_externally_reminder(
     session: Session,
-) -> model.DeveloperMessageItem | None:
+) -> message.DeveloperMessage | None:
     """Remind agent about user/linter' changes to the files in FileTracker, provding the newest content of the file."""
-    changed_files: list[tuple[str, str, list[model.ImageURLPart] | None]] = []
-    collected_images: list[model.ImageURLPart] = []
+    changed_files: list[tuple[str, str, list[message.ImageURLPart] | None]] = []
+    collected_images: list[message.ImageURLPart] = []
     if session.file_tracker and len(session.file_tracker) > 0:
         for path, status in session.file_tracker.items():
             try:
@@ -320,9 +333,10 @@ async def file_changed_externally_reminder(
                             ReadTool.ReadArguments(file_path=path)
                         )  # This tool will update file tracker
                         if tool_result.status == "success":
-                            changed_files.append((path, tool_result.output or "", tool_result.images))
-                            if tool_result.images:
-                                collected_images.extend(tool_result.images)
+                            images = [part for part in tool_result.parts if isinstance(part, message.ImageURLPart)]
+                            changed_files.append((path, tool_result.output_text, images or None))
+                            if images:
+                                collected_images.extend(images)
                     finally:
                         reset_tool_context(context_token)
             except (
@@ -341,10 +355,12 @@ async def file_changed_externally_reminder(
                 for file_path, file_content, _ in changed_files
             ]
         )
-        return model.DeveloperMessageItem(
-            content=f"""<system-reminder>{changed_files_str}""",
+        return message.DeveloperMessage(
+            parts=message.parts_from_text_and_images(
+                f"""<system-reminder>{changed_files_str}""",
+                collected_images or None,
+            ),
             external_file_changes=[file_path for file_path, _, _ in changed_files],
-            images=collected_images or None,
         )
 
     return None
@@ -393,26 +409,28 @@ class Memory(BaseModel):
 def get_last_user_message_image_count(session: Session) -> int:
     """Get image count from the last user message in conversation history."""
     for item in reversed(session.conversation_history):
-        if isinstance(item, model.ToolResultItem):
+        if isinstance(item, message.ToolResultMessage):
             return 0
-        if isinstance(item, model.UserMessageItem):
-            return len(item.images) if item.images else 0
+        if isinstance(item, message.UserMessage):
+            return len([part for part in item.parts if isinstance(part, message.ImageURLPart)])
     return 0
 
 
-async def image_reminder(session: Session) -> model.DeveloperMessageItem | None:
+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:
         return None
 
-    return model.DeveloperMessageItem(
-        content=f"<system-reminder>User attached {image_count} image{'s' if image_count > 1 else ''} in their message. Make sure to analyze and reference these images as needed.</system-reminder>",
+    return message.DeveloperMessage(
+        parts=message.text_parts_from_str(
+            f"<system-reminder>User attached {image_count} image{'s' if image_count > 1 else ''} in their message. Make sure to analyze and reference these images as needed.</system-reminder>"
+        ),
         user_image_count=image_count,
     )
 
 
-async def skill_reminder(session: Session) -> model.DeveloperMessageItem | None:
+async def skill_reminder(session: Session) -> message.DeveloperMessage | None:
     """Load skill content when user references a skill with $skill syntax."""
     skill_name = get_skill_from_user_input(session)
     if not skill_name:
@@ -436,8 +454,8 @@ async def skill_reminder(session: Session) -> model.DeveloperMessageItem | None:
 </skill>
 </system-reminder>"""
 
-    return model.DeveloperMessageItem(
-        content=content,
+    return message.DeveloperMessage(
+        parts=message.text_parts_from_str(content),
         skill_name=skill.name,
     )
 
@@ -461,7 +479,7 @@ def _mark_memory_loaded(session: Session, path: str) -> None:
     session.file_tracker[path] = model.FileStatus(mtime=mtime, content_sha256=content_sha256, is_memory=True)
 
 
-async def memory_reminder(session: Session) -> model.DeveloperMessageItem | None:
+async def memory_reminder(session: Session) -> message.DeveloperMessage | None:
     """CLAUDE.md AGENTS.md"""
     memory_paths = get_memory_paths()
     memories: list[Memory] = []
@@ -485,8 +503,9 @@ async def memory_reminder(session: Session) -> model.DeveloperMessageItem | None
             if patterns:
                 memory_mentioned[memory.path] = patterns
 
-        return model.DeveloperMessageItem(
-            content=f"""<system-reminder>As you answer the user's questions, you can use the following context:
+        return message.DeveloperMessage(
+            parts=message.text_parts_from_str(
+                f"""<system-reminder>As you answer the user's questions, you can use the following context:
 
 # claudeMd
 Codebase and user instructions are shown below. Be sure to adhere to these instructions. IMPORTANT: These instructions OVERRIDE any default behavior and you MUST follow them exactly as written.
@@ -499,19 +518,17 @@ ALWAYS prefer editing an existing file to creating a new one.
 NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
 
 IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context unless it is highly relevant to your task.
-</system-reminder>""",
+</system-reminder>"""
+            ),
             memory_paths=[memory.path for memory in memories],
             memory_mentioned=memory_mentioned or None,
         )
     return None
 
 
-MEMORY_FILE_NAMES = ["CLAUDE.md", "AGENTS.md", "AGENT.md"]
-
-
 async def last_path_memory_reminder(
     session: Session,
-) -> model.DeveloperMessageItem | None:
+) -> message.DeveloperMessage | None:
     """Load CLAUDE.md/AGENTS.md from directories containing files in file_tracker.
 
     Uses session.file_tracker to detect accessed paths (works for both tool calls
@@ -579,9 +596,11 @@ async def last_path_memory_reminder(
             if patterns:
                 memory_mentioned[memory.path] = patterns
 
-        return model.DeveloperMessageItem(
-            content=f"""<system-reminder>{memories_str}
-</system-reminder>""",
+        return message.DeveloperMessage(
+            parts=message.text_parts_from_str(
+                f"""<system-reminder>{memories_str}
+</system-reminder>"""
+            ),
             memory_paths=[memory.path for memory in memories],
             memory_mentioned=memory_mentioned or None,
         )