ripperdoc 0.2.3__py3-none-any.whl → 0.2.4__py3-none-any.whl

ripperdoc/tools/enter_plan_mode_tool.py

@@ -0,0 +1,223 @@
+"""Enter plan mode tool for complex task planning.
+
+This tool allows the AI to request entering plan mode for complex tasks
+that require careful exploration and design before implementation.
+"""
+
+from __future__ import annotations
+
+from textwrap import dedent
+from typing import AsyncGenerator, Optional
+
+from pydantic import BaseModel
+
+from ripperdoc.core.tool import (
+    Tool,
+    ToolOutput,
+    ToolResult,
+    ToolUseContext,
+    ValidationResult,
+)
+from ripperdoc.utils.log import get_logger
+
+logger = get_logger()
+
+TOOL_NAME = "EnterPlanMode"
+ASK_USER_QUESTION_TOOL = "AskUserQuestion"
+
+ENTER_PLAN_MODE_PROMPT = dedent(
+    """\
+    Use this tool when you encounter a complex task that requires careful planning and exploration before implementation. This tool transitions you into plan mode where you can thoroughly explore the codebase and design an implementation approach.
+
+    ## When to Use This Tool
+
+    Use EnterPlanMode when ANY of these conditions apply:
+
+    1. **Multiple Valid Approaches**: The task can be solved in several different ways, each with trade-offs
+       - Example: "Add caching to the API" - could use Redis, in-memory, file-based, etc.
+       - Example: "Improve performance" - many optimization strategies possible
+
+    2. **Significant Architectural Decisions**: The task requires choosing between architectural patterns
+       - Example: "Add real-time updates" - WebSockets vs SSE vs polling
+       - Example: "Implement state management" - Redux vs Context vs custom solution
+
+    3. **Large-Scale Changes**: The task touches many files or systems
+       - Example: "Refactor the authentication system"
+       - Example: "Migrate from REST to GraphQL"
+
+    4. **Unclear Requirements**: You need to explore before understanding the full scope
+       - Example: "Make the app faster" - need to profile and identify bottlenecks
+       - Example: "Fix the bug in checkout" - need to investigate root cause
+
+    5. **User Input Needed**: You'll need to ask clarifying questions before starting
+       - If you would use {ask_tool} to clarify the approach, consider EnterPlanMode instead
+       - Plan mode lets you explore first, then present options with context
+
+    ## When NOT to Use This Tool
+
+    Do NOT use EnterPlanMode for:
+    - Simple, straightforward tasks with obvious implementation
+    - Small bug fixes where the solution is clear
+    - Adding a single function or small feature
+    - Tasks you're already confident how to implement
+    - Research-only tasks (use the Task tool with explore agent instead)
+
+    ## What Happens in Plan Mode
+
+    In plan mode, you'll:
+    1. Thoroughly explore the codebase using Glob, Grep, and Read tools
+    2. Understand existing patterns and architecture
+    3. Design an implementation approach
+    4. Present your plan to the user for approval
+    5. Use {ask_tool} if you need to clarify approaches
+    6. Exit plan mode with ExitPlanMode when ready to implement
+
+    ## Examples
+
+    ### GOOD - Use EnterPlanMode:
+    User: "Add user authentication to the app"
+    - This requires architectural decisions (session vs JWT, where to store tokens, middleware structure)
+
+    User: "Optimize the database queries"
+    - Multiple approaches possible, need to profile first, significant impact
+
+    User: "Implement dark mode"
+    - Architectural decision on theme system, affects many components
+
+    ### BAD - Don't use EnterPlanMode:
+    User: "Fix the typo in the README"
+    - Straightforward, no planning needed
+
+    User: "Add a console.log to debug this function"
+    - Simple, obvious implementation
+
+    User: "What files handle routing?"
+    - Research task, not implementation planning
+
+    ## Important Notes
+
+    - This tool REQUIRES user approval - they must consent to entering plan mode
+    - Be thoughtful about when to use it - unnecessary plan mode slows down simple tasks
+    - If unsure whether to use it, err on the side of starting implementation
+    - You can always ask the user "Would you like me to plan this out first?"
+    """
+).format(ask_tool=ASK_USER_QUESTION_TOOL)
+
+
+PLAN_MODE_INSTRUCTIONS = dedent(
+    """\
+    In plan mode, you should:
+    1. Thoroughly explore the codebase to understand existing patterns
+    2. Identify similar features and architectural approaches
+    3. Consider multiple approaches and their trade-offs
+    4. Use AskUserQuestion if you need to clarify the approach
+    5. Design a concrete implementation strategy
+    6. When ready, use ExitPlanMode to present your plan for approval
+
+    Remember: DO NOT write or edit any files yet. This is a read-only exploration and planning phase."""
+)
+
+
+class EnterPlanModeToolInput(BaseModel):
+    """Input for the EnterPlanMode tool.
+
+    This tool takes no input parameters - it simply requests to enter plan mode.
+    """
+
+    pass
+
+
+class EnterPlanModeToolOutput(BaseModel):
+    """Output from the EnterPlanMode tool."""
+
+    message: str
+    entered: bool = True
+
+
+class EnterPlanModeTool(Tool[EnterPlanModeToolInput, EnterPlanModeToolOutput]):
+    """Tool for entering plan mode for complex tasks."""
+
+    @property
+    def name(self) -> str:
+        return TOOL_NAME
+
+    async def description(self) -> str:
+        return (
+            "Requests permission to enter plan mode for complex tasks "
+            "requiring exploration and design"
+        )
+
+    @property
+    def input_schema(self) -> type[EnterPlanModeToolInput]:
+        return EnterPlanModeToolInput
+
+    async def prompt(self, safe_mode: bool = False) -> str:  # noqa: ARG002
+        return ENTER_PLAN_MODE_PROMPT
+
+    def user_facing_name(self) -> str:
+        return ""
+
+    def is_read_only(self) -> bool:
+        return True
+
+    def is_concurrency_safe(self) -> bool:
+        return True
+
+    def needs_permissions(
+        self, input_data: Optional[EnterPlanModeToolInput] = None  # noqa: ARG002
+    ) -> bool:
+        return True
+
+    async def validate_input(
+        self,
+        input_data: EnterPlanModeToolInput,
+        context: Optional[ToolUseContext] = None,
+    ) -> ValidationResult:
+        """Validate that this tool is not being used in an agent context."""
+        if context and context.agent_id:
+            return ValidationResult(
+                result=False,
+                message="EnterPlanMode tool cannot be used in agent contexts",
+            )
+        return ValidationResult(result=True)
+
+    def render_result_for_assistant(self, output: EnterPlanModeToolOutput) -> str:
+        """Render the tool output for the AI assistant."""
+        if not output.entered:
+            return "User declined to enter plan mode. Continue with normal implementation."
+        return f"{output.message}\n\n{PLAN_MODE_INSTRUCTIONS}"
+
+    def render_tool_use_message(
+        self, input_data: EnterPlanModeToolInput, verbose: bool = False  # noqa: ARG002
+    ) -> str:
+        """Render the tool use message for display."""
+        return "Requesting to enter plan mode"
+
+    async def call(
+        self,
+        input_data: EnterPlanModeToolInput,  # noqa: ARG002
+        context: ToolUseContext,
+    ) -> AsyncGenerator[ToolOutput, None]:
+        """Execute the tool to enter plan mode."""
+        if context.agent_id:
+            output = EnterPlanModeToolOutput(
+                message="EnterPlanMode tool cannot be used in agent contexts",
+                entered=False,
+            )
+            yield ToolResult(
+                data=output,
+                result_for_assistant=self.render_result_for_assistant(output),
+            )
+            return
+
+        output = EnterPlanModeToolOutput(
+            message=(
+                "Entered plan mode. You should now focus on exploring "
+                "the codebase and designing an implementation approach."
+            ),
+            entered=True,
+        )
+        yield ToolResult(
+            data=output,
+            result_for_assistant=self.render_result_for_assistant(output),
+        )

ripperdoc/tools/exit_plan_mode_tool.py

@@ -0,0 +1,150 @@
+"""Exit plan mode tool for presenting implementation plans.
+
+This tool allows the AI to exit plan mode and present an implementation
+plan to the user for approval before starting to code.
+"""
+
+from __future__ import annotations
+
+from textwrap import dedent
+from typing import AsyncGenerator, Optional
+
+from pydantic import BaseModel, Field
+
+from ripperdoc.core.tool import (
+    Tool,
+    ToolOutput,
+    ToolResult,
+    ToolUseContext,
+    ValidationResult,
+)
+from ripperdoc.utils.log import get_logger
+
+logger = get_logger()
+
+TOOL_NAME = "ExitPlanMode"
+
+EXIT_PLAN_MODE_PROMPT = dedent(
+    """\
+    Use this tool when you are in plan mode and have finished writing your plan to the plan file and are ready for user approval.
+
+    ## How This Tool Works
+    - You should have already written your plan to the plan file specified in the plan mode system message
+    - This tool does NOT take the plan content as a parameter - it will read the plan from the file you wrote
+    - This tool simply signals that you're done planning and ready for the user to review and approve
+    - The user will see the contents of your plan file when they review it
+
+    ## When to Use This Tool
+    IMPORTANT: Only use this tool when the task requires planning the implementation steps of a task that requires writing code. For research tasks where you're gathering information, searching files, reading files or in general trying to understand the codebase - do NOT use this tool.
+
+    ## Handling Ambiguity in Plans
+    Before using this tool, ensure your plan is clear and unambiguous. If there are multiple valid approaches or unclear requirements:
+    1. Use the AskUserQuestion tool to clarify with the user
+    2. Ask about specific implementation choices (e.g., architectural patterns, which library to use)
+    3. Clarify any assumptions that could affect the implementation
+    4. Edit your plan file to incorporate user feedback
+    5. Only proceed with ExitPlanMode after resolving ambiguities and updating the plan file
+
+    ## Examples
+
+    1. Initial task: "Search for and understand the implementation of vim mode in the codebase" - Do not use the exit plan mode tool because you are not planning the implementation steps of a task.
+    2. Initial task: "Help me implement yank mode for vim" - Use the exit plan mode tool after you have finished planning the implementation steps of the task.
+    3. Initial task: "Add a new feature to handle user authentication" - If unsure about auth method (OAuth, JWT, etc.), use AskUserQuestion first, then use exit plan mode tool after clarifying the approach.
+    """
+)
+
+
+class ExitPlanModeToolInput(BaseModel):
+    """Input for the ExitPlanMode tool."""
+
+    plan: str = Field(
+        description="The plan you came up with, that you want to run by the user for approval. "
+        "Supports markdown. The plan should be pretty concise."
+    )
+
+
+class ExitPlanModeToolOutput(BaseModel):
+    """Output from the ExitPlanMode tool."""
+
+    plan: str
+    is_agent: bool = False
+
+
+class ExitPlanModeTool(Tool[ExitPlanModeToolInput, ExitPlanModeToolOutput]):
+    """Tool for exiting plan mode and presenting a plan for approval."""
+
+    @property
+    def name(self) -> str:
+        return TOOL_NAME
+
+    async def description(self) -> str:
+        return "Prompts the user to exit plan mode and start coding"
+
+    @property
+    def input_schema(self) -> type[ExitPlanModeToolInput]:
+        return ExitPlanModeToolInput
+
+    async def prompt(self, safe_mode: bool = False) -> str:  # noqa: ARG002
+        return EXIT_PLAN_MODE_PROMPT
+
+    def user_facing_name(self) -> str:
+        return "Exit plan mode"
+
+    def is_read_only(self) -> bool:
+        return True
+
+    def is_concurrency_safe(self) -> bool:
+        return True
+
+    def needs_permissions(
+        self, input_data: Optional[ExitPlanModeToolInput] = None  # noqa: ARG002
+    ) -> bool:
+        return True
+
+    async def validate_input(
+        self,
+        input_data: ExitPlanModeToolInput,
+        context: Optional[ToolUseContext] = None,  # noqa: ARG002
+    ) -> ValidationResult:
+        """Validate that plan is not empty."""
+        if not input_data.plan or not input_data.plan.strip():
+            return ValidationResult(
+                result=False,
+                message="Plan cannot be empty",
+            )
+        return ValidationResult(result=True)
+
+    def render_result_for_assistant(self, output: ExitPlanModeToolOutput) -> str:
+        """Render the tool output for the AI assistant."""
+        return f"Exit plan mode and start coding now. Plan:\n{output.plan}"
+
+    def render_tool_use_message(
+        self, input_data: ExitPlanModeToolInput, verbose: bool = False  # noqa: ARG002
+    ) -> str:
+        """Render the tool use message for display."""
+        plan = input_data.plan
+        snippet = f"{plan[:77]}..." if len(plan) > 80 else plan
+        return f"Share plan for approval: {snippet}"
+
+    async def call(
+        self,
+        input_data: ExitPlanModeToolInput,
+        context: ToolUseContext,
+    ) -> AsyncGenerator[ToolOutput, None]:
+        """Execute the tool to exit plan mode."""
+        # Invoke the exit plan mode callback if available
+        if context.on_exit_plan_mode:
+            try:
+                context.on_exit_plan_mode()
+            except Exception:
+                logger.debug("[exit_plan_mode_tool] Failed to call on_exit_plan_mode")
+
+        is_agent = bool(context.agent_id)
+        output = ExitPlanModeToolOutput(
+            plan=input_data.plan,
+            is_agent=is_agent,
+        )
+        yield ToolResult(
+            data=output,
+            result_for_assistant=self.render_result_for_assistant(output),
+        )

ripperdoc/tools/mcp_tools.py

@@ -30,6 +30,7 @@ from ripperdoc.utils.mcp import (
     load_mcp_servers_async,
     shutdown_mcp_runtime,
 )
+from ripperdoc.utils.token_estimation import estimate_tokens
 
 
 logger = get_logger()
@@ -40,6 +41,55 @@ except Exception:  # pragma: no cover - SDK may be missing at runtime
     mcp_types = None  # type: ignore[assignment]
     logger.exception("[mcp_tools] MCP SDK unavailable during import")
 
+DEFAULT_MAX_MCP_OUTPUT_TOKENS = 25_000
+MIN_MCP_OUTPUT_TOKENS = 1_000
+DEFAULT_MCP_WARNING_FRACTION = 0.8
+
+
+def _get_mcp_token_limits() -> tuple[int, int]:
+    """Compute warning and hard limits for MCP output size."""
+    max_tokens = os.getenv("RIPPERDOC_MCP_MAX_OUTPUT_TOKENS")
+    try:
+        max_tokens_int = int(max_tokens) if max_tokens else DEFAULT_MAX_MCP_OUTPUT_TOKENS
+    except (TypeError, ValueError):
+        max_tokens_int = DEFAULT_MAX_MCP_OUTPUT_TOKENS
+    max_tokens_int = max(MIN_MCP_OUTPUT_TOKENS, max_tokens_int)
+
+    warn_env = os.getenv("RIPPERDOC_MCP_WARNING_TOKENS")
+    try:
+        warn_tokens_int = int(warn_env) if warn_env else int(max_tokens_int * DEFAULT_MCP_WARNING_FRACTION)
+    except (TypeError, ValueError):
+        warn_tokens_int = int(max_tokens_int * DEFAULT_MCP_WARNING_FRACTION)
+    warn_tokens_int = max(MIN_MCP_OUTPUT_TOKENS, min(warn_tokens_int, max_tokens_int))
+    return warn_tokens_int, max_tokens_int
+
+
+def _evaluate_mcp_output_size(
+    result_text: Optional[str],
+    server_name: str,
+    tool_name: str,
+) -> tuple[Optional[str], Optional[str], int]:
+    """Return (warning, error, token_estimate) for an MCP result text."""
+    warn_tokens, max_tokens = _get_mcp_token_limits()
+    token_estimate = estimate_tokens(result_text or "")
+
+    if token_estimate > max_tokens:
+        error_text = (
+            f"MCP response from {server_name}:{tool_name} is ~{token_estimate:,} tokens, "
+            f"which exceeds the configured limit of {max_tokens}. "
+            "Refine the request (pagination/filtering) or raise RIPPERDOC_MCP_MAX_OUTPUT_TOKENS."
+        )
+        return None, error_text, token_estimate
+
+    warning_text = None
+    if result_text and token_estimate >= warn_tokens:
+        line_count = result_text.count("\n") + 1
+        warning_text = (
+            f"WARNING: Large MCP response (~{token_estimate:,} tokens, {line_count:,} lines). "
+            "This can fill the context quickly; consider pagination or filters."
+        )
+    return warning_text, None, token_estimate
+
 
 def _content_block_to_text(block: Any) -> str:
     block_type = getattr(block, "type", None) or (
@@ -370,6 +420,9 @@ class ReadMcpResourceOutput(BaseModel):
     uri: str
     content: Optional[str] = None
     contents: List[ResourceContentPart] = Field(default_factory=list)
+    token_estimate: Optional[int] = None
+    warning: Optional[str] = None
+    is_error: bool = False
 
 
 class McpToolCallOutput(BaseModel):
@@ -382,6 +435,8 @@ class McpToolCallOutput(BaseModel):
     content_blocks: Optional[List[Any]] = None
     structured_content: Optional[dict] = None
     is_error: bool = False
+    token_estimate: Optional[int] = None
+    warning: Optional[str] = None
 
 
 class ReadMcpResourceTool(Tool[ReadMcpResourceInput, ReadMcpResourceOutput]):
@@ -552,9 +607,35 @@ class ReadMcpResourceTool(Tool[ReadMcpResourceInput, ReadMcpResourceOutput]):
         read_result: Any = ReadMcpResourceOutput(
             server=input_data.server, uri=input_data.uri, content=content_text, contents=parts
         )
+        assistant_text = self.render_result_for_assistant(read_result)  # type: ignore[arg-type]
+        warning_text, error_text, token_estimate = _evaluate_mcp_output_size(
+            assistant_text, input_data.server, f"resource:{input_data.uri}"
+        )
+
+        if error_text:
+            limited_result = ReadMcpResourceOutput(
+                server=input_data.server,
+                uri=input_data.uri,
+                content=None,
+                contents=[],
+                token_estimate=token_estimate,
+                warning=None,
+                is_error=True,
+            )
+            yield ToolResult(data=limited_result, result_for_assistant=error_text)
+            return
+
+        annotated_result = read_result.model_copy(
+            update={"token_estimate": token_estimate, "warning": warning_text}
+        )
+
+        final_text = assistant_text or ""
+        if not final_text and warning_text:
+            final_text = warning_text
+
         yield ToolResult(
-            data=read_result,
-            result_for_assistant=self.render_result_for_assistant(read_result),  # type: ignore[arg-type]
+            data=annotated_result,
+            result_for_assistant=final_text,  # type: ignore[arg-type]
         )
 
 
@@ -715,9 +796,37 @@ class DynamicMcpTool(Tool[BaseModel, McpToolCallOutput]):
                 structured_content=structured,
                 is_error=getattr(call_result, "isError", False),
             )
+            base_result_text = self.render_result_for_assistant(output)
+            warning_text, error_text, token_estimate = _evaluate_mcp_output_size(
+                base_result_text, self.server_name, self.tool_info.name
+            )
+
+            if error_text:
+                limited_output = McpToolCallOutput(
+                    server=self.server_name,
+                    tool=self.tool_info.name,
+                    content=None,
+                    text=None,
+                    content_blocks=None,
+                    structured_content=None,
+                    is_error=True,
+                    token_estimate=token_estimate,
+                    warning=None,
+                )
+                yield ToolResult(data=limited_output, result_for_assistant=error_text)
+                return
+
+            annotated_output = output.model_copy(
+                update={"token_estimate": token_estimate, "warning": warning_text}
+            )
+
+            final_text = base_result_text or ""
+            if not final_text and warning_text:
+                final_text = warning_text
+
             yield ToolResult(
-                data=output,
-                result_for_assistant=self.render_result_for_assistant(output),
+                data=annotated_output,
+                result_for_assistant=final_text,
             )
         except Exception as exc:  # pragma: no cover - runtime errors
             output = McpToolCallOutput(

ripperdoc/tools/task_tool.py

@@ -10,6 +10,9 @@ from pydantic import BaseModel, Field
 from ripperdoc.core.agents import (
     AgentDefinition,
     AgentLoadResult,
+    FILE_EDIT_TOOL_NAME,
+    GREP_TOOL_NAME,
+    VIEW_TOOL_NAME,
     clear_agent_cache,
     load_agent_definitions,
     resolve_agent_tools,
@@ -70,12 +73,92 @@ class TaskTool(Tool[TaskToolInput, TaskToolOutput]):
         del safe_mode
         clear_agent_cache()
         agents: AgentLoadResult = load_agent_definitions()
-        agent_lines = "\n".join(summarize_agent(agent) for agent in agents.active_agents)
+
+        agent_lines: List[str] = []
+        for agent in agents.active_agents:
+            properties = (
+                "Properties: access to current context; "
+                if getattr(agent, "fork_context", False)
+                else ""
+            )
+            tools_label = "All tools"
+            if getattr(agent, "tools", None):
+                tools_label = (
+                    "All tools" if "*" in agent.tools else ", ".join(agent.tools)
+                )
+            agent_lines.append(
+                f"- {agent.agent_type}: {agent.when_to_use} ({properties}Tools: {tools_label})"
+            )
+
+        agent_block = "\n".join(agent_lines) or "- general-purpose (built-in)"
+
+        task_tool_name = self.name
+        file_read_tool_name = VIEW_TOOL_NAME
+        search_tool_name = GREP_TOOL_NAME
+        code_tool_name = FILE_EDIT_TOOL_NAME
+        background_fetch_tool_name = task_tool_name
+
         return (
-            "Use this tool to delegate a well-scoped task to a subagent. "
-            "Always set subagent_type to one of the available agent types below. "
-            "Provide a detailed prompt so the agent can work autonomously and return a single, concise report.\n\n"
-            f"Available agents:\n{agent_lines or '- general-purpose (built-in)'}"
+            f"Launch a new agent to handle complex, multi-step tasks autonomously. \n\n"
+            f"The {task_tool_name} tool launches specialized agents (subprocesses) that autonomously handle complex tasks. Each agent type has specific capabilities and tools available to it.\n\n"
+            f"Available agent types and the tools they have access to:\n"
+            f"{agent_block}\n\n"
+            f"When using the {task_tool_name} tool, you must specify a subagent_type parameter to select which agent type to use.\n\n"
+            f"When NOT to use the {task_tool_name} tool:\n"
+            f"- If you want to read a specific file path, use the {file_read_tool_name} or {search_tool_name} tool instead of the {task_tool_name} tool, to find the match more quickly\n"
+            f'- If you are searching for a specific class definition like "class Foo", use the {search_tool_name} tool instead, to find the match more quickly\n'
+            f"- If you are searching for code within a specific file or set of 2-3 files, use the {file_read_tool_name} tool instead of the {task_tool_name} tool, to find the match more quickly\n"
+            "- Other tasks that are not related to the agent descriptions above\n"
+            "\n"
+            "\n"
+            "Usage notes:\n"
+            "- Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses\n"
+            "- When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.\n"
+            f"- You can optionally run agents in the background using the run_in_background parameter. When an agent runs in the background, you will need to use {background_fetch_tool_name} to retrieve its results once it's done. You can continue to work while background agents run - When you need their results to continue you can use {background_fetch_tool_name} in blocking mode to pause and wait for their results.\n"
+            "- 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.\n"
+            "- 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.\n"
+            "- Provide clear, detailed prompts so the agent can work autonomously and return exactly the information you need.\n"
+            '- Agents with "access to current context" can see the full conversation history before the tool call. When using these agents, you can write concise prompts that reference earlier context (e.g., "investigate the error discussed above") instead of repeating information. The agent will receive all prior messages and understand the context.\n'
+            "- The agent's outputs should generally be trusted\n"
+            "- Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent\n"
+            "- If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.\n"
+            f'- If the user specifies that they want you to run agents "in parallel", you MUST send a single message with multiple {task_tool_name} tool use content blocks. For example, if you need to launch both a code-reviewer agent and a test-runner agent in parallel, send a single message with both tool calls.\n'
+            "\n"
+            "Example usage:\n"
+            "\n"
+            "<example_agent_descriptions>\n"
+            '"code-reviewer": use this agent after you are done writing a signficant piece of code\n'
+            '"greeting-responder": use this agent when to respond to user greetings with a friendly joke\n'
+            "</example_agent_description>\n"
+            "\n"
+            "<example>\n"
+            'user: "Please write a function that checks if a number is prime"\n'
+            "assistant: Sure let me write a function that checks if a number is prime\n"
+            f"assistant: First let me use the {code_tool_name} tool to write a function that checks if a number is prime\n"
+            f"assistant: I'm going to use the {code_tool_name} tool to write the following code:\n"
+            "<code>\n"
+            "function isPrime(n) {\n"
+            "  if (n <= 1) return false\n"
+            "  for (let i = 2; i * i <= n; i++) {\n"
+            "    if (n % i === 0) return false\n"
+            "  }\n"
+            "  return true\n"
+            "}\n"
+            "</code>\n"
+            "<commentary>\n"
+            "Since a signficant piece of code was written and the task was completed, now use the code-reviewer agent to review the code\n"
+            "</commentary>\n"
+            "assistant: Now let me use the code-reviewer agent to review the code\n"
+            f"assistant: Uses the {task_tool_name} tool to launch the code-reviewer agent \n"
+            "</example>\n"
+            "\n"
+            "<example>\n"
+            'user: "Hello"\n'
+            "<commentary>\n"
+            "Since the user is greeting, use the greeting-responder agent to respond with a friendly joke\n"
+            "</commentary>\n"
+            f'assistant: "I\'m going to use the {task_tool_name} tool to launch the greeting-responder agent\"\n'
+            "</example>"
         )
 
     def is_read_only(self) -> bool: