Framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks.
feat: extract and publish tool metadata to AMP (#4298)
Thiago Moretto98b7626784d1
diff --git a/lib/crewai/src/crewai/cli/plus_api.py b/lib/crewai/src/crewai/cli/plus_api.pyindex 665221f1e..ac7acfda9 100644--- a/lib/crewai/src/crewai/cli/plus_api.py+++ b/lib/crewai/src/crewai/cli/plus_api.py@@ -73,6 +73,7 @@ class PlusAPI:description: str | None,encoded_file: str,available_exports: list[dict[str, Any]] | None = None,+ tools_metadata: list[dict[str, Any]] | None = None,) -> httpx.Response:params = {"handle": handle,@@ -81,6 +82,9 @@ class PlusAPI:"file": encoded_file,"description": description,"available_exports": available_exports,+ "tools_metadata": {"package": handle, "tools": tools_metadata}+ if tools_metadata is not None+ else None,}return self._make_request("POST", f"{self.TOOLS_RESOURCE}", json=params)diff --git a/lib/crewai/src/crewai/cli/tools/main.py b/lib/crewai/src/crewai/cli/tools/main.pyindex 0a9f68af0..72c1e6e25 100644--- a/lib/crewai/src/crewai/cli/tools/main.py+++ b/lib/crewai/src/crewai/cli/tools/main.py@@ -17,6 +17,7 @@ from crewai.cli.constants import DEFAULT_CREWAI_ENTERPRISE_URLfrom crewai.cli.utils import (build_env_with_tool_repository_credentials,extract_available_exports,+ extract_tools_metadata,get_project_description,get_project_name,get_project_version,@@ -101,6 +102,18 @@ class ToolCommand(BaseCommand, PlusAPIMixin):console.print(f"[green]Found these tools to publish: {', '.join([e['name'] for e in available_exports])}[/green]")++ console.print("[bold blue]Extracting tool metadata...[/bold blue]")+ try:+ tools_metadata = extract_tools_metadata()+ except Exception as e:+ console.print(+ f"[yellow]Warning: Could not extract tool metadata: {e}[/yellow]\n"+ f"Publishing will continue without detailed metadata."+ )+ tools_metadata = []++ self._print_tools_preview(tools_metadata)self._print_current_organization()with tempfile.TemporaryDirectory() as temp_build_dir:@@ -118,7 +131,7 @@ class ToolCommand(BaseCommand, PlusAPIMixin):"Project build failed. Please ensure that the command `uv build --sdist` completes successfully.",style="bold red",)- raise SystemExit+ raise SystemExit(1)tarball_path = os.path.join(temp_build_dir, tarball_filename)with open(tarball_path, "rb") as file:@@ -134,6 +147,7 @@ class ToolCommand(BaseCommand, PlusAPIMixin):description=project_description,encoded_file=f"data:application/x-gzip;base64,{encoded_tarball}",available_exports=available_exports,+ tools_metadata=tools_metadata,)self._validate_response(publish_response)@@ -246,6 +260,55 @@ class ToolCommand(BaseCommand, PlusAPIMixin):)raise SystemExit+ def _print_tools_preview(self, tools_metadata: list[dict[str, Any]]) -> None:+ if not tools_metadata:+ console.print("[yellow]No tool metadata extracted.[/yellow]")+ return++ console.print(+ f"\n[bold]Tools to be published ({len(tools_metadata)}):[/bold]\n"+ )++ for tool in tools_metadata:+ console.print(f" [bold cyan]{tool.get('name', 'Unknown')}[/bold cyan]")+ if tool.get("module"):+ console.print(f" Module: {tool.get('module')}")+ console.print(f" Name: {tool.get('humanized_name', 'N/A')}")+ console.print(+ f" Description: {tool.get('description', 'N/A')[:80]}{'...' if len(tool.get('description', '')) > 80 else ''}"+ )++ init_params = tool.get("init_params_schema", {}).get("properties", {})+ if init_params:+ required = tool.get("init_params_schema", {}).get("required", [])+ console.print(" Init parameters:")+ for param_name, param_info in init_params.items():+ param_type = param_info.get("type", "any")+ is_required = param_name in required+ req_marker = "[red]*[/red]" if is_required else ""+ default = (+ f" = {param_info['default']}" if "default" in param_info else ""+ )+ console.print(+ f" - {param_name}: {param_type}{default} {req_marker}"+ )++ env_vars = tool.get("env_vars", [])+ if env_vars:+ console.print(" Environment variables:")+ for env_var in env_vars:+ req_marker = "[red]*[/red]" if env_var.get("required") else ""+ default = (+ f" (default: {env_var['default']})"+ if env_var.get("default")+ else ""+ )+ console.print(+ f" - {env_var['name']}: {env_var.get('description', 'N/A')}{default} {req_marker}"+ )++ console.print()+def _print_current_organization(self) -> None:settings = Settings()if settings.org_uuid:diff --git a/lib/crewai/src/crewai/cli/utils.py b/lib/crewai/src/crewai/cli/utils.pyindex aa3455469..a23bdc85a 100644--- a/lib/crewai/src/crewai/cli/utils.py+++ b/lib/crewai/src/crewai/cli/utils.py@@ -1,10 +1,15 @@-from functools import reduce+from collections.abc import Generator, Mapping+from contextlib import contextmanager+from functools import lru_cache, reduce+import hashlibimport importlib.util+import inspectfrom inspect import getmro, isclass, isfunction, ismethodimport osfrom pathlib import Pathimport shutilimport sys+import typesfrom typing import Any, cast, get_type_hintsimport click@@ -544,43 +549,62 @@ def build_env_with_tool_repository_credentials(return env-def _load_tools_from_init(init_file: Path) -> list[dict[str, Any]]:+@contextmanager+def _load_module_from_file(+ init_file: Path, module_name: str | None = None+) -> Generator[types.ModuleType | None, None, None]:"""- Load and validate tools from a given __init__.py file.+ Context manager for loading a module from file with automatic cleanup.++ Yields the loaded module or None if loading fails."""- spec = importlib.util.spec_from_file_location("temp_module", init_file)+ if module_name is None:+ module_name = (+ f"temp_module_{hashlib.sha256(str(init_file).encode()).hexdigest()[:8]}"+ )+ spec = importlib.util.spec_from_file_location(module_name, init_file)if not spec or not spec.loader:- return []+ yield None+ returnmodule = importlib.util.module_from_spec(spec)- sys.modules["temp_module"] = module+ sys.modules[module_name] = moduletry:spec.loader.exec_module(module)+ yield module+ finally:+ sys.modules.pop(module_name, None)- if not hasattr(module, "__all__"):- console.print(- f"Warning: No __all__ defined in {init_file}",- style="bold yellow",- )- raise SystemExit(1)-- return [- {- "name": name,- }- for name in module.__all__- if hasattr(module, name) and is_valid_tool(getattr(module, name))- ]+def _load_tools_from_init(init_file: Path) -> list[dict[str, Any]]:+ """+ Load and validate tools from a given __init__.py file.+ """+ try:+ with _load_module_from_file(init_file) as module:+ if module is None:+ return []++ if not hasattr(module, "__all__"):+ console.print(+ f"Warning: No __all__ defined in {init_file}",+ style="bold yellow",+ )+ raise SystemExit(1)++ return [+ {"name": name}+ for name in module.__all__+ if hasattr(module, name) and is_valid_tool(getattr(module, name))+ ]+ except SystemExit:+ raiseexcept Exception as e:console.print(f"[red]Warning: Could not load {init_file}: {e!s}[/red]")raise SystemExit(1) from e- finally:- sys.modules.pop("temp_module", None)-def _print_no_tools_warning() -> None:"""@@ -610,3 +634,242 @@ def _print_no_tools_warning() -> None:" # ... implementation\n"" return result\n")+++def extract_tools_metadata(dir_path: str = "src") -> list[dict[str, Any]]:+ """+ Extract rich metadata from tool classes in the project.++ Returns a list of tool metadata dictionaries containing:+ - name: Class name+ - humanized_name: From name field default+ - description: From description field default+ - run_params_schema: JSON Schema for _run() params (from args_schema)+ - init_params_schema: JSON Schema for __init__ params (filtered)+ - env_vars: List of environment variable dicts+ """+ tools_metadata: list[dict[str, Any]] = []++ for init_file in Path(dir_path).glob("**/__init__.py"):+ tools = _extract_tool_metadata_from_init(init_file)+ tools_metadata.extend(tools)++ return tools_metadata+++def _extract_tool_metadata_from_init(init_file: Path) -> list[dict[str, Any]]:+ """+ Load module from init file and extract metadata from valid tool classes.+ """+ from crewai.tools.base_tool import BaseTool++ try:+ with _load_module_from_file(init_file) as module:+ if module is None:+ return []++ exported_names = getattr(module, "__all__", None)+ if not exported_names:+ return []++ tools_metadata = []+ for name in exported_names:+ obj = getattr(module, name, None)+ if obj is None or not (+ inspect.isclass(obj) and issubclass(obj, BaseTool)+ ):+ continue+ if tool_info := _extract_single_tool_metadata(obj):+ tools_metadata.append(tool_info)++ return tools_metadata+ except Exception as e:+ console.print(+ f"[yellow]Warning: Could not extract metadata from {init_file}: {e}[/yellow]"+ )+ return []+++def _extract_single_tool_metadata(tool_class: type) -> dict[str, Any] | None:+ """+ Extract metadata from a single tool class.+ """+ try:+ core_schema = cast(Any, tool_class).__pydantic_core_schema__+ if not core_schema:+ return None++ schema = _unwrap_schema(core_schema)+ fields = schema.get("schema", {}).get("fields", {})++ try:+ file_path = inspect.getfile(tool_class)+ relative_path = Path(file_path).relative_to(Path.cwd())+ module_path = relative_path.with_suffix("")+ if module_path.parts[0] == "src":+ module_path = Path(*module_path.parts[1:])+ if module_path.name == "__init__":+ module_path = module_path.parent+ module = ".".join(module_path.parts)+ except (TypeError, ValueError):+ module = tool_class.__module__++ return {+ "name": tool_class.__name__,+ "module": module,+ "humanized_name": _extract_field_default(+ fields.get("name"), fallback=tool_class.__name__+ ),+ "description": str(+ _extract_field_default(fields.get("description"))+ ).strip(),+ "run_params_schema": _extract_run_params_schema(fields.get("args_schema")),+ "init_params_schema": _extract_init_params_schema(tool_class),+ "env_vars": _extract_env_vars(fields.get("env_vars")),+ }++ except Exception:+ return None+++def _unwrap_schema(schema: Mapping[str, Any] | dict[str, Any]) -> dict[str, Any]:+ """+ Unwrap nested schema structures to get to the actual schema definition.+ """+ result: dict[str, Any] = dict(schema)+ while (+ result.get("type")+ in {"function-after", "function-before", "function-wrap", "default"}+ and "schema" in result+ ):+ result = dict(result["schema"])+ if result.get("type") == "definitions" and "schema" in result:+ result = dict(result["schema"])+ return result+++def _extract_field_default(+ field: dict[str, Any] | None, fallback: str | list[Any] = ""+) -> str | list[Any] | int:+ """+ Extract the default value from a field schema.+ """+ if not field:+ return fallback++ schema = field.get("schema", {})+ default = schema.get("default")+ return default if isinstance(default, (list, str, int)) else fallback+++@lru_cache(maxsize=1)+def _get_schema_generator() -> type:+ """Get a SchemaGenerator that omits non-serializable defaults."""+ from pydantic.json_schema import GenerateJsonSchema+ from pydantic_core import PydanticOmit++ class SchemaGenerator(GenerateJsonSchema):+ def handle_invalid_for_json_schema(+ self, schema: Any, error_info: Any+ ) -> dict[str, Any]:+ raise PydanticOmit++ return SchemaGenerator+++def _extract_run_params_schema(+ args_schema_field: dict[str, Any] | None,+) -> dict[str, Any]:+ """+ Extract JSON Schema for the tool's run parameters from args_schema field.+ """+ from pydantic import BaseModel++ if not args_schema_field:+ return {}++ args_schema_class = args_schema_field.get("schema", {}).get("default")+ if not (+ inspect.isclass(args_schema_class) and issubclass(args_schema_class, BaseModel)+ ):+ return {}++ try:+ return args_schema_class.model_json_schema(+ schema_generator=_get_schema_generator()+ )+ except Exception:+ return {}+++_IGNORED_INIT_PARAMS = frozenset(+ {+ "name",+ "description",+ "env_vars",+ "args_schema",+ "description_updated",+ "cache_function",+ "result_as_answer",+ "max_usage_count",+ "current_usage_count",+ "package_dependencies",+ }+)+++def _extract_init_params_schema(tool_class: type) -> dict[str, Any]:+ """+ Extract JSON Schema for the tool's __init__ parameters, filtering out base fields.+ """+ try:+ json_schema: dict[str, Any] = cast(Any, tool_class).model_json_schema(+ schema_generator=_get_schema_generator(), mode="serialization"+ )+ filtered_properties = {+ key: value+ for key, value in json_schema.get("properties", {}).items()+ if key not in _IGNORED_INIT_PARAMS+ }+ json_schema["properties"] = filtered_properties+ if "required" in json_schema:+ json_schema["required"] = [+ key for key in json_schema["required"] if key in filtered_properties+ ]+ return json_schema+ except Exception:+ return {}+++def _extract_env_vars(env_vars_field: dict[str, Any] | None) -> list[dict[str, Any]]:+ """+ Extract environment variable definitions from env_vars field.+ """+ from crewai.tools.base_tool import EnvVar++ if not env_vars_field:+ return []++ schema = env_vars_field.get("schema", {})+ default = schema.get("default")+ if default is None:+ default_factory = schema.get("default_factory")+ if callable(default_factory):+ try:+ default = default_factory()+ except Exception:+ default = []++ if not isinstance(default, list):+ return []++ return [+ {+ "name": env_var.name,+ "description": env_var.description,+ "required": env_var.required,+ "default": env_var.default,+ }+ for env_var in default+ if isinstance(env_var, EnvVar)+ ]diff --git a/lib/crewai/tests/cli/test_plus_api.py b/lib/crewai/tests/cli/test_plus_api.pyindex 95a322e21..79baeb733 100644--- a/lib/crewai/tests/cli/test_plus_api.py+++ b/lib/crewai/tests/cli/test_plus_api.py@@ -136,6 +136,7 @@ class TestPlusAPI(unittest.TestCase):"file": encoded_file,"description": description,"available_exports": None,+ "tools_metadata": None,}mock_make_request.assert_called_once_with("POST", "/crewai_plus/api/v1/tools", json=params@@ -173,6 +174,7 @@ class TestPlusAPI(unittest.TestCase):"file": encoded_file,"description": description,"available_exports": None,+ "tools_metadata": None,}self.assert_request_with_org_id(@@ -201,6 +203,48 @@ class TestPlusAPI(unittest.TestCase):"file": encoded_file,"description": description,"available_exports": None,+ "tools_metadata": None,+ }+ mock_make_request.assert_called_once_with(+ "POST", "/crewai_plus/api/v1/tools", json=params+ )+ self.assertEqual(response, mock_response)++ @patch("crewai.cli.plus_api.PlusAPI._make_request")+ def test_publish_tool_with_tools_metadata(self, mock_make_request):+ mock_response = MagicMock()+ mock_make_request.return_value = mock_response+ handle = "test_tool_handle"+ public = True+ version = "1.0.0"+ description = "Test tool description"+ encoded_file = "encoded_test_file"+ available_exports = [{"name": "MyTool"}]+ tools_metadata = [+ {+ "name": "MyTool",+ "humanized_name": "my_tool",+ "description": "A test tool",+ "run_params_schema": {"type": "object", "properties": {}},+ "init_params_schema": {"type": "object", "properties": {}},+ "env_vars": [{"name": "API_KEY", "description": "API key", "required": True, "default": None}],+ }+ ]++ response = self.api.publish_tool(+ handle, public, version, description, encoded_file,+ available_exports=available_exports,+ tools_metadata=tools_metadata,+ )++ params = {+ "handle": handle,+ "public": public,+ "version": version,+ "file": encoded_file,+ "description": description,+ "available_exports": available_exports,+ "tools_metadata": {"package": handle, "tools": tools_metadata},}mock_make_request.assert_called_once_with("POST", "/crewai_plus/api/v1/tools", json=paramsdiff --git a/lib/crewai/tests/cli/test_utils.py b/lib/crewai/tests/cli/test_utils.pyindex 5baf1cffe..fc006a417 100644--- a/lib/crewai/tests/cli/test_utils.py+++ b/lib/crewai/tests/cli/test_utils.py@@ -363,3 +363,290 @@ def test_get_crews_ignores_template_directories(utils.get_crews()assert not template_crew_detected+++# Tests for extract_tools_metadata+++def test_extract_tools_metadata_empty_project(temp_project_dir):+ """Test that extract_tools_metadata returns empty list for empty project."""+ metadata = utils.extract_tools_metadata(dir_path=str(temp_project_dir))+ assert metadata == []+++def test_extract_tools_metadata_no_init_file(temp_project_dir):+ """Test that extract_tools_metadata returns empty list when no __init__.py exists."""+ (temp_project_dir / "some_file.py").write_text("print('hello')")+ metadata = utils.extract_tools_metadata(dir_path=str(temp_project_dir))+ assert metadata == []+++def test_extract_tools_metadata_empty_init_file(temp_project_dir):+ """Test that extract_tools_metadata returns empty list for empty __init__.py."""+ create_init_file(temp_project_dir, "")+ metadata = utils.extract_tools_metadata(dir_path=str(temp_project_dir))+ assert metadata == []+++def test_extract_tools_metadata_no_all_variable(temp_project_dir):+ """Test that extract_tools_metadata returns empty list when __all__ is not defined."""+ create_init_file(+ temp_project_dir,+ "from crewai.tools import BaseTool\n\nclass MyTool(BaseTool):\n pass",+ )+ metadata = utils.extract_tools_metadata(dir_path=str(temp_project_dir))+ assert metadata == []+++def test_extract_tools_metadata_valid_base_tool_class(temp_project_dir):+ """Test that extract_tools_metadata extracts metadata from a valid BaseTool class."""+ create_init_file(+ temp_project_dir,+ """from crewai.tools import BaseTool++class MyTool(BaseTool):+ name: str = "my_tool"+ description: str = "A test tool"++__all__ = ['MyTool']+""",+ )+ metadata = utils.extract_tools_metadata(dir_path=str(temp_project_dir))+ assert len(metadata) == 1+ assert metadata[0]["name"] == "MyTool"+ assert metadata[0]["humanized_name"] == "my_tool"+ assert metadata[0]["description"] == "A test tool"+++def test_extract_tools_metadata_with_args_schema(temp_project_dir):+ """Test that extract_tools_metadata extracts run_params_schema from args_schema."""+ create_init_file(+ temp_project_dir,+ """from crewai.tools import BaseTool+from pydantic import BaseModel++class MyToolInput(BaseModel):+ query: str+ limit: int = 10++class MyTool(BaseTool):+ name: str = "my_tool"+ description: str = "A test tool"+ args_schema: type[BaseModel] = MyToolInput++__all__ = ['MyTool']+""",+ )+ metadata = utils.extract_tools_metadata(dir_path=str(temp_project_dir))+ assert len(metadata) == 1+ assert metadata[0]["name"] == "MyTool"+ run_params = metadata[0]["run_params_schema"]+ assert "properties" in run_params+ assert "query" in run_params["properties"]+ assert "limit" in run_params["properties"]+++def test_extract_tools_metadata_with_env_vars(temp_project_dir):+ """Test that extract_tools_metadata extracts env_vars."""+ create_init_file(+ temp_project_dir,+ """from crewai.tools import BaseTool+from crewai.tools.base_tool import EnvVar++class MyTool(BaseTool):+ name: str = "my_tool"+ description: str = "A test tool"+ env_vars: list[EnvVar] = [+ EnvVar(name="MY_API_KEY", description="API key for service", required=True),+ EnvVar(name="MY_OPTIONAL_VAR", description="Optional var", required=False, default="default_value"),+ ]++__all__ = ['MyTool']+""",+ )+ metadata = utils.extract_tools_metadata(dir_path=str(temp_project_dir))+ assert len(metadata) == 1+ env_vars = metadata[0]["env_vars"]+ assert len(env_vars) == 2+ assert env_vars[0]["name"] == "MY_API_KEY"+ assert env_vars[0]["description"] == "API key for service"+ assert env_vars[0]["required"] is True+ assert env_vars[1]["name"] == "MY_OPTIONAL_VAR"+ assert env_vars[1]["required"] is False+ assert env_vars[1]["default"] == "default_value"+++def test_extract_tools_metadata_with_env_vars_field_default_factory(temp_project_dir):+ """Test that extract_tools_metadata extracts env_vars declared with Field(default_factory=...)."""+ create_init_file(+ temp_project_dir,+ """from crewai.tools import BaseTool+from crewai.tools.base_tool import EnvVar+from pydantic import Field++class MyTool(BaseTool):+ name: str = "my_tool"+ description: str = "A test tool"+ env_vars: list[EnvVar] = Field(+ default_factory=lambda: [+ EnvVar(name="MY_TOOL_API", description="API token for my tool", required=True),+ ]+ )++__all__ = ['MyTool']+""",+ )+ metadata = utils.extract_tools_metadata(dir_path=str(temp_project_dir))+ assert len(metadata) == 1+ env_vars = metadata[0]["env_vars"]+ assert len(env_vars) == 1+ assert env_vars[0]["name"] == "MY_TOOL_API"+ assert env_vars[0]["description"] == "API token for my tool"+ assert env_vars[0]["required"] is True+++def test_extract_tools_metadata_with_custom_init_params(temp_project_dir):+ """Test that extract_tools_metadata extracts init_params_schema with custom params."""+ create_init_file(+ temp_project_dir,+ """from crewai.tools import BaseTool++class MyTool(BaseTool):+ name: str = "my_tool"+ description: str = "A test tool"+ api_endpoint: str = "https://api.example.com"+ timeout: int = 30++__all__ = ['MyTool']+""",+ )+ metadata = utils.extract_tools_metadata(dir_path=str(temp_project_dir))+ assert len(metadata) == 1+ init_params = metadata[0]["init_params_schema"]+ assert "properties" in init_params+ # Custom params should be included+ assert "api_endpoint" in init_params["properties"]+ assert "timeout" in init_params["properties"]+ # Base params should be filtered out+ assert "name" not in init_params["properties"]+ assert "description" not in init_params["properties"]+++def test_extract_tools_metadata_multiple_tools(temp_project_dir):+ """Test that extract_tools_metadata extracts metadata from multiple tools."""+ create_init_file(+ temp_project_dir,+ """from crewai.tools import BaseTool++class FirstTool(BaseTool):+ name: str = "first_tool"+ description: str = "First test tool"++class SecondTool(BaseTool):+ name: str = "second_tool"+ description: str = "Second test tool"++__all__ = ['FirstTool', 'SecondTool']+""",+ )+ metadata = utils.extract_tools_metadata(dir_path=str(temp_project_dir))+ assert len(metadata) == 2+ names = [m["name"] for m in metadata]+ assert "FirstTool" in names+ assert "SecondTool" in names+++def test_extract_tools_metadata_multiple_init_files(temp_project_dir):+ """Test that extract_tools_metadata extracts metadata from multiple __init__.py files."""+ # Create tool in root __init__.py+ create_init_file(+ temp_project_dir,+ """from crewai.tools import BaseTool++class RootTool(BaseTool):+ name: str = "root_tool"+ description: str = "Root tool"++__all__ = ['RootTool']+""",+ )++ # Create nested package with another tool+ nested_dir = temp_project_dir / "nested"+ nested_dir.mkdir()+ create_init_file(+ nested_dir,+ """from crewai.tools import BaseTool++class NestedTool(BaseTool):+ name: str = "nested_tool"+ description: str = "Nested tool"++__all__ = ['NestedTool']+""",+ )++ metadata = utils.extract_tools_metadata(dir_path=str(temp_project_dir))+ assert len(metadata) == 2+ names = [m["name"] for m in metadata]+ assert "RootTool" in names+ assert "NestedTool" in names+++def test_extract_tools_metadata_ignores_non_tool_exports(temp_project_dir):+ """Test that extract_tools_metadata ignores non-BaseTool exports."""+ create_init_file(+ temp_project_dir,+ """from crewai.tools import BaseTool++class MyTool(BaseTool):+ name: str = "my_tool"+ description: str = "A test tool"++def not_a_tool():+ pass++SOME_CONSTANT = "value"++__all__ = ['MyTool', 'not_a_tool', 'SOME_CONSTANT']+""",+ )+ metadata = utils.extract_tools_metadata(dir_path=str(temp_project_dir))+ assert len(metadata) == 1+ assert metadata[0]["name"] == "MyTool"+++def test_extract_tools_metadata_import_error_returns_empty(temp_project_dir):+ """Test that extract_tools_metadata returns empty list on import error."""+ create_init_file(+ temp_project_dir,+ """from nonexistent_module import something++class MyTool(BaseTool):+ pass++__all__ = ['MyTool']+""",+ )+ # Should not raise, just return empty list+ metadata = utils.extract_tools_metadata(dir_path=str(temp_project_dir))+ assert metadata == []+++def test_extract_tools_metadata_syntax_error_returns_empty(temp_project_dir):+ """Test that extract_tools_metadata returns empty list on syntax error."""+ create_init_file(+ temp_project_dir,+ """from crewai.tools import BaseTool++class MyTool(BaseTool):+ # Missing closing parenthesis+ def __init__(self, name:+ pass++__all__ = ['MyTool']+""",+ )+ # Should not raise, just return empty list+ metadata = utils.extract_tools_metadata(dir_path=str(temp_project_dir))+ assert metadata == []diff --git a/lib/crewai/tests/cli/tools/test_main.py b/lib/crewai/tests/cli/tools/test_main.pyindex 6661011d3..aba6f1075 100644--- a/lib/crewai/tests/cli/tools/test_main.py+++ b/lib/crewai/tests/cli/tools/test_main.py@@ -185,9 +185,14 @@ def test_publish_when_not_in_sync(mock_is_synced, capsys, tool_command):"crewai.cli.tools.main.extract_available_exports",return_value=[{"name": "SampleTool"}],)+@patch(+ "crewai.cli.tools.main.extract_tools_metadata",+ return_value=[{"name": "SampleTool", "humanized_name": "sample_tool", "description": "A sample tool", "run_params_schema": {}, "init_params_schema": {}, "env_vars": []}],+)@patch("crewai.cli.tools.main.ToolCommand._print_current_organization")def test_publish_when_not_in_sync_and_force(mock_print_org,+ mock_tools_metadata,mock_available_exports,mock_is_synced,mock_publish,@@ -222,6 +227,7 @@ def test_publish_when_not_in_sync_and_force(description="A sample tool",encoded_file=unittest.mock.ANY,available_exports=[{"name": "SampleTool"}],+ tools_metadata=[{"name": "SampleTool", "humanized_name": "sample_tool", "description": "A sample tool", "run_params_schema": {}, "init_params_schema": {}, "env_vars": []}],)mock_print_org.assert_called_once()@@ -242,7 +248,12 @@ def test_publish_when_not_in_sync_and_force("crewai.cli.tools.main.extract_available_exports",return_value=[{"name": "SampleTool"}],)+@patch(+ "crewai.cli.tools.main.extract_tools_metadata",+ return_value=[{"name": "SampleTool", "humanized_name": "sample_tool", "description": "A sample tool", "run_params_schema": {}, "init_params_schema": {}, "env_vars": []}],+)def test_publish_success(+ mock_tools_metadata,mock_available_exports,mock_is_synced,mock_publish,@@ -277,6 +288,7 @@ def test_publish_success(description="A sample tool",encoded_file=unittest.mock.ANY,available_exports=[{"name": "SampleTool"}],+ tools_metadata=[{"name": "SampleTool", "humanized_name": "sample_tool", "description": "A sample tool", "run_params_schema": {}, "init_params_schema": {}, "env_vars": []}],)@@ -295,7 +307,12 @@ def test_publish_success("crewai.cli.tools.main.extract_available_exports",return_value=[{"name": "SampleTool"}],)+@patch(+ "crewai.cli.tools.main.extract_tools_metadata",+ return_value=[{"name": "SampleTool", "humanized_name": "sample_tool", "description": "A sample tool", "run_params_schema": {}, "init_params_schema": {}, "env_vars": []}],+)def test_publish_failure(+ mock_tools_metadata,mock_available_exports,mock_publish,mock_open,@@ -336,7 +353,12 @@ def test_publish_failure("crewai.cli.tools.main.extract_available_exports",return_value=[{"name": "SampleTool"}],)+@patch(+ "crewai.cli.tools.main.extract_tools_metadata",+ return_value=[{"name": "SampleTool", "humanized_name": "sample_tool", "description": "A sample tool", "run_params_schema": {}, "init_params_schema": {}, "env_vars": []}],+)def test_publish_api_error(+ mock_tools_metadata,mock_available_exports,mock_publish,mock_open,@@ -362,6 +384,63 @@ def test_publish_api_error(mock_publish.assert_called_once()+@patch("crewai.cli.tools.main.get_project_name", return_value="sample-tool")+@patch("crewai.cli.tools.main.get_project_version", return_value="1.0.0")+@patch("crewai.cli.tools.main.get_project_description", return_value="A sample tool")+@patch("crewai.cli.tools.main.subprocess.run")+@patch("crewai.cli.tools.main.os.listdir", return_value=["sample-tool-1.0.0.tar.gz"])+@patch(+ "crewai.cli.tools.main.open",+ new_callable=unittest.mock.mock_open,+ read_data=b"sample tarball content",+)+@patch("crewai.cli.plus_api.PlusAPI.publish_tool")+@patch("crewai.cli.tools.main.git.Repository.is_synced", return_value=True)+@patch(+ "crewai.cli.tools.main.extract_available_exports",+ return_value=[{"name": "SampleTool"}],+)+@patch(+ "crewai.cli.tools.main.extract_tools_metadata",+ side_effect=Exception("Failed to extract metadata"),+)+def test_publish_metadata_extraction_failure_continues_with_warning(+ mock_tools_metadata,+ mock_available_exports,+ mock_is_synced,+ mock_publish,+ mock_open,+ mock_listdir,+ mock_subprocess_run,+ mock_get_project_description,+ mock_get_project_version,+ mock_get_project_name,+ capsys,+ tool_command,+):+ """Test that metadata extraction failure shows warning but continues publishing."""+ mock_publish_response = MagicMock()+ mock_publish_response.status_code = 200+ mock_publish_response.json.return_value = {"handle": "sample-tool"}+ mock_publish.return_value = mock_publish_response++ tool_command.publish(is_public=True)++ output = capsys.readouterr().out+ assert "Warning: Could not extract tool metadata" in output+ assert "Publishing will continue without detailed metadata" in output+ assert "No tool metadata extracted" in output+ mock_publish.assert_called_once_with(+ handle="sample-tool",+ is_public=True,+ version="1.0.0",+ description="A sample tool",+ encoded_file=unittest.mock.ANY,+ available_exports=[{"name": "SampleTool"}],+ tools_metadata=[],+ )++@patch("crewai.cli.tools.main.Settings")def test_print_current_organization_with_org(mock_settings, capsys, tool_command):mock_settings_instance = MagicMock()