Method register

src/tool/context.py:422–512

Register a tool class or instance. This will: - Create (or reuse) a tool instance - Create a `ToolConfig` - Store it as the current config and append to version history - Register the version in `version_manager` and FAISS index

(self, 
                       tool_cls: Type[Tool],
                       tool_config_dict: Optional[Dict[str, Any]] = None,
                       override: bool = False,
                       version: Optional[str] = None)

            raise
    
    async def register(self, 
                       tool_cls: Type[Tool],
                       tool_config_dict: Optional[Dict[str, Any]] = None,
                       override: bool = False,
                       version: Optional[str] = None) -> ToolConfig:
        """Register a tool class or instance.
        
        This will:
        - Create (or reuse) a tool instance
        - Create a `ToolConfig`
        - Store it as the current config and append to version history
        - Register the version in `version_manager` and FAISS index
        """
        
        try:
            if tool_config_dict is None:
                # Fallback to global config by class name
                tool_config_key = inflection.underscore(tool_cls.__name__)
                tool_config_dict = config.get(tool_config_key, {})
            
            # Instantiate tool immediately (register is a runtime operation)
            try:
                tool_instance = tool_cls(**tool_config_dict)
            except Exception as e:
                logger.error(f"| ❌ Failed to create tool instance for {tool_cls.__name__}: {e}")
                raise ValueError(f"Failed to instantiate tool {tool_cls.__name__} with provided config: {e}")
            
            tool_name = tool_instance.name
            tool_description = tool_instance.description
            tool_metadata = tool_instance.metadata
            # Get require_grad from tool_config_dict if provided, otherwise from tool_instance
            tool_require_grad = tool_config_dict.get("require_grad", tool_instance.require_grad) if tool_config_dict and "require_grad" in tool_config_dict else tool_instance.require_grad
            
            # Get or generate version from version_manager
            if version is None:
                tool_version = await version_manager.get_version("tool", tool_name)
            else:
                tool_version = version
                
            # Get tool code
            tool_code = dynamic_manager.get_source_code(tool_cls)
            if not tool_code:
                logger.warning(f"| ⚠️ Tool {tool_name} is dynamic but source code cannot be extracted")
            
            # Get tool parameters
            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)
            
            # --- Build ToolConfig ---
            tool_config = ToolConfig(
                name=tool_name,
                description=tool_description,
                metadata=tool_metadata,
                require_grad=tool_require_grad,
                version=tool_version,
                cls=tool_cls,