Serena

Instructions

Implementation Reference

• src/serena/tools/workflow_tools.py:70-84 (handler)

  The core handler implementation for the 'think_about_task_adherence' tool. It inherits from Tool and its apply() method returns a rendered prompt for task adherence reflection.

  class ThinkAboutTaskAdherenceTool(Tool):
      """
      Thinking tool for determining whether the agent is still on track with the current task.
      """
  
      def apply(self) -> str:
          """
          Think about the task at hand and whether you are still on track.
          Especially important if the conversation has been going on for a while and there
          has been a lot of back and forth.
  
          This tool should ALWAYS be called before you insert, replace, or delete code.
          """
          return self.prompt_factory.create_think_about_task_adherence()

• src/serena/generated/generated_prompt_factory.py:23-24 (helper)

  Helper method in the prompt factory that renders the specific prompt template used by the tool handler.

  def create_think_about_task_adherence(self) -> str:
      return self._render_prompt("think_about_task_adherence", locals())

• src/serena/tools/tools_base.py:355-427 (registration)

  The ToolRegistry dynamically discovers and registers all Tool subclasses, including ThinkAboutTaskAdherenceTool, by scanning subclasses in serena.tools packages. This makes the tool available for instantiation in the agent.

  @singleton
  class ToolRegistry:
      def __init__(self) -> None:
          self._tool_dict: dict[str, RegisteredTool] = {}
          for cls in iter_subclasses(Tool):
              if not any(cls.__module__.startswith(pkg) for pkg in tool_packages):
                  continue
              is_optional = issubclass(cls, ToolMarkerOptional)
              name = cls.get_name_from_cls()
              if name in self._tool_dict:
                  raise ValueError(f"Duplicate tool name found: {name}. Tool classes must have unique names.")
              self._tool_dict[name] = RegisteredTool(tool_class=cls, is_optional=is_optional, tool_name=name)
  
      def get_tool_class_by_name(self, tool_name: str) -> type[Tool]:
          return self._tool_dict[tool_name].tool_class
  
      def get_all_tool_classes(self) -> list[type[Tool]]:
          return list(t.tool_class for t in self._tool_dict.values())
  
      def get_tool_classes_default_enabled(self) -> list[type[Tool]]:
          """
          :return: the list of tool classes that are enabled by default (i.e. non-optional tools).
          """
          return [t.tool_class for t in self._tool_dict.values() if not t.is_optional]
  
      def get_tool_classes_optional(self) -> list[type[Tool]]:
          """
          :return: the list of tool classes that are optional (i.e. disabled by default).
          """
          return [t.tool_class for t in self._tool_dict.values() if t.is_optional]
  
      def get_tool_names_default_enabled(self) -> list[str]:
          """
          :return: the list of tool names that are enabled by default (i.e. non-optional tools).
          """
          return [t.tool_name for t in self._tool_dict.values() if not t.is_optional]
  
      def get_tool_names_optional(self) -> list[str]:
          """
          :return: the list of tool names that are optional (i.e. disabled by default).
          """
          return [t.tool_name for t in self._tool_dict.values() if t.is_optional]
  
      def get_tool_names(self) -> list[str]:
          """
          :return: the list of all tool names.
          """
          return list(self._tool_dict.keys())
  
      def print_tool_overview(
          self, tools: Iterable[type[Tool] | Tool] | None = None, include_optional: bool = False, only_optional: bool = False
      ) -> None:
          """
          Print a summary of the tools. If no tools are passed, a summary of the selection of tools (all, default or only optional) is printed.
          """
          if tools is None:
              if only_optional:
                  tools = self.get_tool_classes_optional()
              elif include_optional:
                  tools = self.get_all_tool_classes()
              else:
                  tools = self.get_tool_classes_default_enabled()
  
          tool_dict: dict[str, type[Tool] | Tool] = {}
          for tool_class in tools:
              tool_dict[tool_class.get_name_from_cls()] = tool_class
          for tool_name in sorted(tool_dict.keys()):
              tool_class = tool_dict[tool_name]
              print(f" * `{tool_name}`: {tool_class.get_tool_description().strip()}")
  
      def is_valid_tool_name(self, tool_name: str) -> bool:
          return tool_name in self._tool_dict

• src/serena/mcp.py:252-259 (registration)

  Registers the tool instances as MCP tools by name in the FastMCP server, using a wrapper around the Tool's apply method.

  def _set_mcp_tools(self, mcp: FastMCP, openai_tool_compatible: bool = False) -> None:
      """Update the tools in the MCP server"""
      if mcp is not None:
          mcp._tool_manager._tools = {}
          for tool in self._iter_tools():
              mcp_tool = self.make_mcp_tool(tool, openai_tool_compatible=openai_tool_compatible)
              mcp._tool_manager._tools[tool.get_name()] = mcp_tool
          log.info(f"Starting MCP server with {len(mcp._tool_manager._tools)} tools: {list(mcp._tool_manager._tools.keys())}")