Method register_tool_class

src/tool/context.py:169–228

Register a tool class synchronously. Args: tool_cls: Tool class to register

(tool_cls: Type[Tool])

        tool_configs: Dict[str, ToolConfig] = {}
        
        async def register_tool_class(tool_cls: Type[Tool]):
            """Register a tool class synchronously.
            
            Args:
                tool_cls: Tool class to register
            """
            try:
                # Get tool config from global config
                tool_config_key = inflection.underscore(tool_cls.__name__)
                tool_config_dict = config.get(tool_config_key, {})
                tool_require_grad = tool_config_dict.get("require_grad", False) if tool_config_dict and "require_grad" in tool_config_dict else False
                
                # Get tool properties from tool class
                tool_name = tool_cls.model_fields['name'].default
                tool_description = tool_cls.model_fields['description'].default
                tool_metadata = tool_cls.model_fields['metadata'].default
                
                # Get or generate version from version_manager
                tool_version = await version_manager.get_version("tool", tool_name)
                
                # Get full module source code
                tool_code = dynamic_manager.get_full_module_source(tool_cls)
                
                tool_parameters = dynamic_manager.get_parameters(tool_cls)
                tool_function_calling = dynamic_manager.build_function_calling(tool_name, tool_description, tool_parameters)
                tool_text = dynamic_manager.build_text_representation(tool_name, tool_description, tool_parameters)
                tool_args_schema = dynamic_manager.build_args_schema(tool_name, tool_parameters)
                
                # Create tool config (ToolConfig.id is auto-incremented internally if needed)
                tool_config = ToolConfig(
                    name=tool_name,
                    description=tool_description,
                    version=tool_version,
                    cls=tool_cls,
                    config=tool_config_dict,
                    instance=None,
                    function_calling=tool_function_calling,
                    text=tool_text,
                    args_schema=tool_args_schema,
                    metadata=tool_metadata,
                    require_grad=tool_require_grad,
                    code=tool_code,
                )
                
                # Store tool config
                tool_configs[tool_name] = tool_config
                
                # Store in version history (by version string)
                if tool_name not in self._tool_history_versions:
                    self._tool_history_versions[tool_name] = {}
                self._tool_history_versions[tool_name][tool_version] = tool_config
                
                # Register version to version manager
                await version_manager.register_version("tool", tool_name, tool_version)
                
                logger.info(f"| 📝 Registered tool: {tool_name} ({tool_cls.__name__})")
                
            except Exception as e: