feat(frontend):优化前端页面设计

kilostar/api/__init__.py

@@ -141,7 +141,7 @@ else:
 
 @serve.deployment
 @serve.ingress(app)
-class kilostarGateway:
+class KiloStarGateway:
     gateway: Dict[str, WebSocket]
 
     def __init__(self):

kilostar/api/agent.py

@@ -28,8 +28,7 @@ agent_router = APIRouter(prefix="/api/v1/agent", tags=["agent"])
 
 
 class AgentRegister(BaseModel):
-    """AgentRegister 核心组件类。
-    这是一个领域数据模型或功能封装类，承载了 AgentRegister 相关的内聚属性定义与状态维护。它的存在隔离了局部的业务复杂性，并对外提供了类型安全的访问接口。"""
+    """``POST /agent`` 入参（远程模型）：通过 provider + model_id 加载系统节点。"""
 
     provider_title: str
     model_id: str
@@ -38,8 +37,7 @@ class AgentRegister(BaseModel):
 
 
 class AgentLocalRegister(BaseModel):
-    """AgentLocalRegister 核心组件类。
-    这是一个领域数据模型或功能封装类，承载了 AgentLocalRegister 相关的内聚属性定义与状态维护。它的存在隔离了局部的业务复杂性，并对外提供了类型安全的访问接口。"""
+    """``POST /agent`` 入参（本地模型）：通过本地路径加载系统节点。"""
 
     path: str
     individual_name: str
@@ -50,10 +48,7 @@ class AgentLocalRegister(BaseModel):
 async def get_system_nodes(
     _: TokenData = Depends(RoleChecker(allowed_roles=UserAuthority.USER)),
 ):
-    """处理针对 get system nodes 相关的 HTTP API 请求。
-    该接口负责解析前端传入的载荷数据，调用底层核心业务逻辑进行处理，并组装标准化的 JSON 响应。
-    Args:        _ (TokenData): 参与 get system nodes 逻辑运算或数据构建的上下文依赖对象。
-    Returns:        : 序列化后的标准网络响应模型（如包含业务状态码、成功标志及对应的数据载荷 Data）。"""
+    """返回三大系统节点（regulatory/consciousness/control）当前的持久化配置。"""
     postgres_database = ray_actor_hook("postgres_database").postgres_database
     configs = await postgres_database.get_all_system_node_configs.remote()
     return {"system_nodes": configs}
@@ -64,10 +59,7 @@ async def load_agent(
     agent_register: Union[AgentRegister, AgentLocalRegister],
     _: TokenData = Depends(RoleChecker(allowed_roles=UserAuthority.USER)),
 ):
-    """处理针对 load agent 相关的 HTTP API 请求。
-    该接口负责解析前端传入的载荷数据，调用底层核心业务逻辑进行处理，并组装标准化的 JSON 响应。
-    Args:        agent_register (Union[AgentRegister, AgentLocalRegister]): 参与 load agent 逻辑运算或数据构建的上下文依赖对象。        _ (TokenData): 参与 load agent 逻辑运算或数据构建的上下文依赖对象。
-    Returns:        : 序列化后的标准网络响应模型（如包含业务状态码、成功标志及对应的数据载荷 Data）。"""
+    """加载/重载某个系统节点的 Agent：先持久化配置，再调用对应节点 Actor 的 ``create_agent``。"""
     global_state_machine = ray_actor_hook("global_state_machine").global_state_machine
     postgres_database = ray_actor_hook("postgres_database").postgres_database
 
@@ -76,7 +68,6 @@ async def load_agent(
 
     elif isinstance(agent_register, AgentRegister):
         try:
-            # Persist configuration
             await postgres_database.upsert_system_node_config.remote(
                 agent_register.individual_name,
                 agent_register.provider_title,
@@ -84,7 +75,6 @@ async def load_agent(
                 agent_register.tools,
             )
 
-            # Load agent into state machine
             match agent_register.individual_name:
                 case "regulatory_node":
                     node = ray_actor_hook("regulatory_node").regulatory_node
@@ -118,8 +108,7 @@ async def load_agent(
 
 
 class WorkerIndividualCreate(BaseModel):
-    """WorkerIndividualCreate 核心组件类。
-    这是一个具体的 Worker 智能体实体类，代表着具备特定人设、领域技能或长文本处理能力的数字员工。它可以被控制器动态拉起，并在安全沙箱内执行复杂的工作流指令与多步骤推理任务。"""
+    """``POST /worker`` 入参：创建一个 Worker Agent 所需的完整配置。"""
 
     agent_name: str
     agent_type: AgentType
@@ -134,8 +123,7 @@ class WorkerIndividualCreate(BaseModel):
 
 
 class WorkerIndividualUpdate(BaseModel):
-    """WorkerIndividualUpdate 核心组件类。
-    这是一个具体的 Worker 智能体实体类，代表着具备特定人设、领域技能或长文本处理能力的数字员工。它可以被控制器动态拉起，并在安全沙箱内执行复杂的工作流指令与多步骤推理任务。"""
+    """``PUT /worker/{agent_id}`` 入参：可选字段构成的局部更新载荷。"""
 
     agent_name: Optional[str] = None
     agent_type: Optional[AgentType] = None
@@ -154,10 +142,7 @@ async def create_worker_individual(
     worker_data: WorkerIndividualCreate,
     token_data: TokenData = Depends(RoleChecker(allowed_roles=UserAuthority.USER)),
 ):
-    """处理针对 create worker individual 相关的 HTTP API 请求。
-    该接口负责解析前端传入的载荷数据，调用底层核心业务逻辑进行处理，并组装标准化的 JSON 响应。
-    Args:        worker_data (WorkerIndividualCreate): 从客户端传递过来或由上游组件生成的核心业务数据体，通常需要进一步的清洗和结构化解析。        token_data (TokenData): 从客户端传递过来或由上游组件生成的核心业务数据体，通常需要进一步的清洗和结构化解析。
-    Returns:        : 序列化后的标准网络响应模型（如包含业务状态码、成功标志及对应的数据载荷 Data）。"""
+    """创建一个 Worker Agent，``owner_id`` 自动绑定为当前登录用户。"""
     postgres_database = ray_actor_hook("postgres_database").postgres_database
     data_dict = worker_data.model_dump()
     data_dict["owner_id"] = token_data.user_id
@@ -169,10 +154,7 @@ async def create_worker_individual(
 async def get_worker_individual_list(
     token_data: TokenData = Depends(Accessor.get_current_user),
 ):
-    """处理针对 get worker individual list 相关的 HTTP API 请求。
-    该接口负责解析前端传入的载荷数据，调用底层核心业务逻辑进行处理，并组装标准化的 JSON 响应。
-    Args:        token_data (TokenData): 从客户端传递过来或由上游组件生成的核心业务数据体，通常需要进一步的清洗和结构化解析。
-    Returns:        : 序列化后的标准网络响应模型（如包含业务状态码、成功标志及对应的数据载荷 Data）。"""
+    """列出当前登录用户名下的全部 Worker Agent。"""
     postgres_database = ray_actor_hook("postgres_database").postgres_database
     workers = await postgres_database.get_worker_individual_list.remote(
         owner_id=token_data.user_id
@@ -184,10 +166,7 @@ async def get_worker_individual_list(
 async def get_worker_individual(
     agent_id: str, token_data: TokenData = Depends(Accessor.get_current_user)
 ):
-    """处理针对 get worker individual 相关的 HTTP API 请求。
-    该接口负责解析前端传入的载荷数据，调用底层核心业务逻辑进行处理，并组装标准化的 JSON 响应。
-    Args:        agent_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 agent 实例。        token_data (TokenData): 从客户端传递过来或由上游组件生成的核心业务数据体，通常需要进一步的清洗和结构化解析。
-    Returns:        : 序列化后的标准网络响应模型（如包含业务状态码、成功标志及对应的数据载荷 Data）。"""
+    """按 ``agent_id`` 查询 Worker Agent；非本人的 Agent 返回 403。"""
     postgres_database = ray_actor_hook("postgres_database").postgres_database
     worker = await postgres_database.get_worker_individual.remote(agent_id=agent_id)
     if not worker:
@@ -205,10 +184,7 @@ async def update_worker_individual(
     worker_data: WorkerIndividualUpdate,
     token_data: TokenData = Depends(Accessor.get_current_user),
 ):
-    """处理针对 update worker individual 相关的 HTTP API 请求。
-    该接口负责解析前端传入的载荷数据，调用底层核心业务逻辑进行处理，并组装标准化的 JSON 响应。
-    Args:        agent_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 agent 实例。        worker_data (WorkerIndividualUpdate): 从客户端传递过来或由上游组件生成的核心业务数据体，通常需要进一步的清洗和结构化解析。        token_data (TokenData): 从客户端传递过来或由上游组件生成的核心业务数据体，通常需要进一步的清洗和结构化解析。
-    Returns:        : 序列化后的标准网络响应模型（如包含业务状态码、成功标志及对应的数据载荷 Data）。"""
+    """局部更新 Worker Agent 配置；同时把状态机里的旧实例移除等待懒加载。"""
     postgres_database = ray_actor_hook("postgres_database").postgres_database
     worker = await postgres_database.get_worker_individual.remote(agent_id=agent_id)
     if not worker:
@@ -236,10 +212,7 @@ async def update_worker_individual(
 async def reload_worker_individual(
     agent_id: str, token_data: TokenData = Depends(Accessor.get_current_user)
 ):
-    """处理针对 reload worker individual 相关的 HTTP API 请求。
-    该接口负责解析前端传入的载荷数据，调用底层核心业务逻辑进行处理，并组装标准化的 JSON 响应。
-    Args:        agent_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 agent 实例。        token_data (TokenData): 从客户端传递过来或由上游组件生成的核心业务数据体，通常需要进一步的清洗和结构化解析。
-    Returns:        : 序列化后的标准网络响应模型（如包含业务状态码、成功标志及对应的数据载荷 Data）。"""
+    """强制把 Worker 从内存池中卸载，下次调用时按最新配置重新加载。"""
     postgres_database = ray_actor_hook("postgres_database").postgres_database
     worker = await postgres_database.get_worker_individual.remote(agent_id=agent_id)
     if not worker:
@@ -259,10 +232,7 @@ async def reload_worker_individual(
 async def delete_worker_individual(
     agent_id: str, token_data: TokenData = Depends(Accessor.get_current_user)
 ):
-    """处理针对 delete worker individual 相关的 HTTP API 请求。
-    该接口负责解析前端传入的载荷数据，调用底层核心业务逻辑进行处理，并组装标准化的 JSON 响应。
-    Args:        agent_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 agent 实例。        token_data (TokenData): 从客户端传递过来或由上游组件生成的核心业务数据体，通常需要进一步的清洗和结构化解析。
-    Returns:        : 序列化后的标准网络响应模型（如包含业务状态码、成功标志及对应的数据载荷 Data）。"""
+    """删除 Worker Agent；非本人 Agent 返回 403。"""
     postgres_database = ray_actor_hook("postgres_database").postgres_database
     worker = await postgres_database.get_worker_individual.remote(agent_id=agent_id)
     if not worker:

kilostar/api/auth.py

@@ -26,8 +26,7 @@ auth_router = APIRouter(prefix="/api/v1/auth", tags=["auth"])
 
 
 class UserRegister(BaseModel):
-    """UserRegister 核心组件类。
-    这是一个领域数据模型或功能封装类，承载了 UserRegister 相关的内聚属性定义与状态维护。它的存在隔离了局部的业务复杂性，并对外提供了类型安全的访问接口。"""
+    """``POST /register`` 入参：用户名 + 明文密码。"""
 
     user_name: str
     password: str
@@ -35,10 +34,7 @@ class UserRegister(BaseModel):
 
 @auth_router.post("/register")
 async def create_user(user_register: UserRegister):
-    """处理针对 create user 相关的 HTTP API 请求。
-    该接口负责解析前端传入的载荷数据，调用底层核心业务逻辑进行处理，并组装标准化的 JSON 响应。
-    Args:        user_register (UserRegister): 参与 create user 逻辑运算或数据构建的上下文依赖对象。
-    Returns:        : 序列化后的标准网络响应模型（如包含业务状态码、成功标志及对应的数据载荷 Data）。"""
+    """注册新用户：异步线程池里做 argon2 哈希，再交由 PostgresDatabase Actor 落库。"""
     postgres_database = ray_actor_hook("postgres_database").postgres_database
     hashed_password = await run_in_threadpool(
         Accessor.hash_password, user_register.password
@@ -50,8 +46,7 @@ async def create_user(user_register: UserRegister):
 
 
 class UserLogin(BaseModel):
-    """UserLogin 核心组件类。
-    这是一个领域数据模型或功能封装类，承载了 UserLogin 相关的内聚属性定义与状态维护。它的存在隔离了局部的业务复杂性，并对外提供了类型安全的访问接口。"""
+    """``POST /login`` 入参：用户名 + 明文密码。"""
 
     user_name: str
     password: str
@@ -59,10 +54,7 @@ class UserLogin(BaseModel):
 
 @auth_router.post("/login")
 async def login_user(user_login: UserLogin):
-    """处理针对 login user 相关的 HTTP API 请求。
-    该接口负责解析前端传入的载荷数据，调用底层核心业务逻辑进行处理，并组装标准化的 JSON 响应。
-    Args:        user_login (UserLogin): 参与 login user 逻辑运算或数据构建的上下文依赖对象。
-    Returns:        : 序列化后的标准网络响应模型（如包含业务状态码、成功标志及对应的数据载荷 Data）。"""
+    """用户登录：查询用户后在线程池中校验口令，校验成功则签发 JWT。"""
     postgres_database = ray_actor_hook("postgres_database").postgres_database
     user = await postgres_database.login_user.remote(user_login.user_name)
     if not user:
@@ -74,8 +66,7 @@ async def login_user(user_login: UserLogin):
 
 
 class ChangeAuthorityRequest(BaseModel):
-    """ChangeAuthorityRequest 核心组件类。
-    这是一个领域数据模型或功能封装类，承载了 ChangeAuthorityRequest 相关的内聚属性定义与状态维护。它的存在隔离了局部的业务复杂性，并对外提供了类型安全的访问接口。"""
+    """``PUT /authority`` 入参：目标用户 ID 及新的权限枚举。"""
 
     user_id: str
     new_authority: UserAuthority

kilostar/api/platform/frontend.py

@@ -26,8 +26,7 @@ client_router = APIRouter(prefix="/api/v1/adapter/client", tags=["client"])
 
 
 class Message(BaseModel):
-    """Message 核心组件类。
-    这是一个领域数据模型或功能封装类，承载了 Message 相关的内聚属性定义与状态维护。它的存在隔离了局部的业务复杂性，并对外提供了类型安全的访问接口。"""
+    """``POST /client`` 入参：来自前端的一段聊天文本。"""
 
     message: str
 
@@ -36,10 +35,7 @@ class Message(BaseModel):
 async def create_message(
     message: Message, token_data: TokenData = Depends(Accessor.get_current_user)
 ):
-    """处理针对 create message 相关的 HTTP API 请求。
-    该接口负责解析前端传入的载荷数据，调用底层核心业务逻辑进行处理，并组装标准化的 JSON 响应。
-    Args:        message (Message): 参与 create message 逻辑运算或数据构建的上下文依赖对象。        token_data (TokenData): 从客户端传递过来或由上游组件生成的核心业务数据体，通常需要进一步的清洗和结构化解析。
-    Returns:        : 序列化后的标准网络响应模型（如包含业务状态码、成功标志及对应的数据载荷 Data）。"""
+    """把前端消息转交给 RegulatoryNode 处理，并把回复透传给前端。"""
     logger.info("收到消息，来源：客户端")
     logger.debug(f"消息内容：{message.message}")
     regulatory_node = ray_actor_hook("regulatory_node").regulatory_node
@@ -56,10 +52,7 @@ async def upload_file(
     file: UploadFile = File(...),
     token_data: TokenData = Depends(Accessor.get_current_user),
 ):
-    """处理针对 upload file 相关的 HTTP API 请求。
-    该接口负责解析前端传入的载荷数据，调用底层核心业务逻辑进行处理，并组装标准化的 JSON 响应。
-    Args:        file (UploadFile): 参与 upload file 逻辑运算或数据构建的上下文依赖对象。        token_data (TokenData): 从客户端传递过来或由上游组件生成的核心业务数据体，通常需要进一步的清洗和结构化解析。
-    Returns:        : 序列化后的标准网络响应模型（如包含业务状态码、成功标志及对应的数据载荷 Data）。"""
+    """以流式方式把上传文件落到 ``uploads/`` 目录；失败抛 500。"""
     try:
         upload_dir = "uploads"
         os.makedirs(upload_dir, exist_ok=True)

kilostar/api/provider.py

@@ -26,8 +26,7 @@ provider_router = APIRouter(prefix="/api/v1/provider", tags=["provider"])
 
 
 class ProviderRegister(BaseModel):
-    """ProviderRegister 核心组件类。
-    这是一个模型/服务提供商适配器类，屏蔽了外部不同供应商（如 OpenAI、Anthropic 等）的底层 API 差异。它负责标准化参数组装、网络请求发送、鉴权处理以及响应结构的反序列化。"""
+    """``POST /provider`` 入参：注册一个模型 Provider 的最小字段集。"""
 
     provider_type: Literal["openai", "claude", "deepseek"]
     provider_title: str
@@ -40,10 +39,7 @@ async def create_provider(
     provider_register: ProviderRegister,
     token_data: TokenData = Depends(RoleChecker(allowed_roles=UserAuthority.USER)),
 ) -> None:
-    """处理针对 create provider 相关的 HTTP API 请求。
-    该接口负责解析前端传入的载荷数据，调用底层核心业务逻辑进行处理，并组装标准化的 JSON 响应。
-    Args:        provider_register (ProviderRegister): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 provider_register 实例。        token_data (TokenData): 从客户端传递过来或由上游组件生成的核心业务数据体，通常需要进一步的清洗和结构化解析。
-    Returns:         (None): 序列化后的标准网络响应模型（如包含业务状态码、成功标志及对应的数据载荷 Data）。"""
+    """注册一个 Provider；owner 为当前登录用户的 ``user_id``。"""
     global_state_machine = ray_actor_hook("global_state_machine").global_state_machine
     await global_state_machine.add_provider_wrap.remote(
         provider_type=provider_register.provider_type,
@@ -58,10 +54,7 @@ async def create_provider(
 async def get_provider_list(
     _: TokenData = Depends(Accessor.get_current_user),
 ) -> Dict[str, Dict[str, Provider]]:
-    """处理针对 get provider list 相关的 HTTP API 请求。
-    该接口负责解析前端传入的载荷数据，调用底层核心业务逻辑进行处理，并组装标准化的 JSON 响应。
-    Args:        _ (TokenData): 参与 get provider list 逻辑运算或数据构建的上下文依赖对象。
-    Returns:         (Dict[str, Dict[str, Provider]]): 序列化后的标准网络响应模型（如包含业务状态码、成功标志及对应的数据载荷 Data）。"""
+    """返回当前所有已注册的 Provider，前端用以展示模型清单。"""
     global_state_machine = ray_actor_hook("global_state_machine").global_state_machine
     provider_list: Dict[
         str, Provider
@@ -76,10 +69,7 @@ async def delete_provider(
         RoleChecker(allowed_roles=UserAuthority.SUPER_ADMINISTRATOR)
     ),
 ) -> dict:
-    """处理针对 delete provider 相关的 HTTP API 请求。
-    该接口负责解析前端传入的载荷数据，调用底层核心业务逻辑进行处理，并组装标准化的 JSON 响应。
-    Args:        provider_title (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 provider_title 实例。        _ (TokenData): 参与 delete provider 逻辑运算或数据构建的上下文依赖对象。
-    Returns:         (dict): 序列化后的标准网络响应模型（如包含业务状态码、成功标志及对应的数据载荷 Data）。"""
+    """删除指定 ``provider_title`` 的 Provider；仅超管可调用。"""
     global_state_machine = ray_actor_hook("global_state_machine").global_state_machine
     await global_state_machine.delete_provider.remote(provider_title=provider_title)
     return {"message": "success"}

kilostar/api/resource.py

@@ -24,8 +24,7 @@ resource_router = APIRouter(prefix="/api/v1/resource")
 
 
 class Skill(BaseModel):
-    """Skill 核心组件类。
-    这是一个领域数据模型或功能封装类，承载了 Skill 相关的内聚属性定义与状态维护。它的存在隔离了局部的业务复杂性，并对外提供了类型安全的访问接口。"""
+    """``POST /skill`` 入参：技能仓库地址及可选子目录路径。"""
 
     repo_url: str
     path: str | None
@@ -35,10 +34,7 @@ class Skill(BaseModel):
 async def install_skill(
     skill: Skill, _: TokenData = Depends(RoleChecker(allowed_roles=UserAuthority.USER))
 ):
-    """处理针对 install skill 相关的 HTTP API 请求。
-    该接口负责解析前端传入的载荷数据，调用底层核心业务逻辑进行处理，并组装标准化的 JSON 响应。
-    Args:        skill (Skill): 参与 install skill 逻辑运算或数据构建的上下文依赖对象。        _ (TokenData): 参与 install skill 逻辑运算或数据构建的上下文依赖对象。
-    Returns:        : 序列化后的标准网络响应模型（如包含业务状态码、成功标志及对应的数据载荷 Data）。"""
+    """通过 viceroy 把 skill 仓库克隆到 ``plugin/skill``，并在状态机中登记。"""
     global_state_machine = ray_actor_hook("global_state_machine").global_state_machine
     # noinspection PyUnresolvedReferences
     import os
@@ -62,10 +58,7 @@ async def install_skill(
 async def get_skills(
     _: TokenData = Depends(RoleChecker(allowed_roles=UserAuthority.USER)),
 ):
-    """处理针对 get skills 相关的 HTTP API 请求。
-    该接口负责解析前端传入的载荷数据，调用底层核心业务逻辑进行处理，并组装标准化的 JSON 响应。
-    Args:        _ (TokenData): 参与 get skills 逻辑运算或数据构建的上下文依赖对象。
-    Returns:        : 序列化后的标准网络响应模型（如包含业务状态码、成功标志及对应的数据载荷 Data）。"""
+    """返回当前状态机中已登记的所有 skill 名称列表。"""
     global_state_machine = ray_actor_hook("global_state_machine").global_state_machine
     skills = await global_state_machine.get_skill_list.remote()
     return {"skills": skills}
@@ -78,10 +71,7 @@ async def delete_skill(
         RoleChecker(allowed_roles=UserAuthority.SUPER_ADMINISTRATOR)
     ),
 ):
-    """处理针对 delete skill 相关的 HTTP API 请求。
-    该接口负责解析前端传入的载荷数据，调用底层核心业务逻辑进行处理，并组装标准化的 JSON 响应。
-    Args:        skill_name (str): 赋予该实体的人类可读名称或标题字符串，主要用于前端 UI 展示、日志记录或模糊检索。        _ (TokenData): 参与 delete skill 逻辑运算或数据构建的上下文依赖对象。
-    Returns:        : 序列化后的标准网络响应模型（如包含业务状态码、成功标志及对应的数据载荷 Data）。"""
+    """从状态机中移除 skill 注册项；不会删除磁盘上的代码文件。"""
     global_state_machine = ray_actor_hook("global_state_machine").global_state_machine
     # Note: this only removes it from the state machine manager.
     await global_state_machine.remove_skill.remote(skill_name)
@@ -92,10 +82,7 @@ async def delete_skill(
 async def get_tools(
     _: TokenData = Depends(RoleChecker(allowed_roles=UserAuthority.USER)),
 ):
-    """处理针对 get tools 相关的 HTTP API 请求。
-    该接口负责解析前端传入的载荷数据，调用底层核心业务逻辑进行处理，并组装标准化的 JSON 响应。
-    Args:        _ (TokenData): 参与 get tools 逻辑运算或数据构建的上下文依赖对象。
-    Returns:        : 序列化后的标准网络响应模型（如包含业务状态码、成功标志及对应的数据载荷 Data）。"""
+    """汇总各作用域 tool_mapper，返回去重后的工具名称列表。"""
     global_state_machine = ray_actor_hook("global_state_machine").global_state_machine
     tool_mapper = await global_state_machine.get_tool_mapper.remote()
     all_tool_names = set()