Merge branch 'main' into devin/1748983984-fix-telemetry-disable-issue-2945

tests/agent_test.py

@@ -309,7 +309,9 @@ def test_cache_hitting():
     def handle_tool_end(source, event):
         received_events.append(event)
 
-    with (patch.object(CacheHandler, "read") as read,):
+    with (
+        patch.object(CacheHandler, "read") as read,
+    ):
         read.return_value = "0"
         task = Task(
             description="What is 2 times 6? Ignore correctness and just return the result of the multiplication tool, you must use the tool.",
@@ -1628,13 +1630,13 @@ def test_agent_execute_task_with_ollama():
 
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_agent_with_knowledge_sources():
-    # Create a knowledge source with some content
     content = "Brandon's favorite color is red and he likes Mexican food."
     string_source = StringKnowledgeSource(content=content)
     with patch("crewai.knowledge") as MockKnowledge:
         mock_knowledge_instance = MockKnowledge.return_value
         mock_knowledge_instance.sources = [string_source]
         mock_knowledge_instance.search.return_value = [{"content": content}]
+        MockKnowledge.add_sources.return_value = [string_source]
 
         agent = Agent(
             role="Information Agent",
@@ -1644,7 +1646,6 @@ def test_agent_with_knowledge_sources():
             knowledge_sources=[string_source],
         )
 
-        # Create a task that requires the agent to use the knowledge
         task = Task(
             description="What is Brandon's favorite color?",
             expected_output="Brandon's favorite color.",
@@ -1652,10 +1653,11 @@ def test_agent_with_knowledge_sources():
         )
 
         crew = Crew(agents=[agent], tasks=[task])
-        result = crew.kickoff()
-
-        # Assert that the agent provides the correct information
-        assert "red" in result.raw.lower()
+        with patch.object(Knowledge, "add_sources") as mock_add_sources:
+            result = crew.kickoff()
+            assert mock_add_sources.called, "add_sources() should have been called"
+            mock_add_sources.assert_called_once()
+            assert "red" in result.raw.lower()
 
 
 @pytest.mark.vcr(filter_headers=["authorization"])
@@ -2036,7 +2038,7 @@ def mock_get_auth_token():
 
 @patch("crewai.cli.plus_api.PlusAPI.get_agent")
 def test_agent_from_repository(mock_get_agent, mock_get_auth_token):
-    from crewai_tools import SerperDevTool
+    from crewai_tools import SerperDevTool, XMLSearchTool
 
     mock_get_response = MagicMock()
     mock_get_response.status_code = 200
@@ -2044,7 +2046,10 @@ def test_agent_from_repository(mock_get_agent, mock_get_auth_token):
         "role": "test role",
         "goal": "test goal",
         "backstory": "test backstory",
-        "tools": [{"name": "SerperDevTool"}],
+        "tools": [
+            {"module": "crewai_tools", "name": "SerperDevTool"},
+            {"module": "crewai_tools", "name": "XMLSearchTool"},
+        ],
     }
     mock_get_agent.return_value = mock_get_response
     agent = Agent(from_repository="test_agent")
@@ -2052,8 +2057,9 @@ def test_agent_from_repository(mock_get_agent, mock_get_auth_token):
     assert agent.role == "test role"
     assert agent.goal == "test goal"
     assert agent.backstory == "test backstory"
-    assert len(agent.tools) == 1
+    assert len(agent.tools) == 2
     assert isinstance(agent.tools[0], SerperDevTool)
+    assert isinstance(agent.tools[1], XMLSearchTool)
 
 
 @patch("crewai.cli.plus_api.PlusAPI.get_agent")
@@ -2066,7 +2072,7 @@ def test_agent_from_repository_override_attributes(mock_get_agent, mock_get_auth
         "role": "test role",
         "goal": "test goal",
         "backstory": "test backstory",
-        "tools": [{"name": "SerperDevTool"}],
+        "tools": [{"name": "SerperDevTool", "module": "crewai_tools"}],
     }
     mock_get_agent.return_value = mock_get_response
     agent = Agent(from_repository="test_agent", role="Custom Role")
@@ -2086,7 +2092,7 @@ def test_agent_from_repository_with_invalid_tools(mock_get_agent, mock_get_auth_
         "role": "test role",
         "goal": "test goal",
         "backstory": "test backstory",
-        "tools": [{"name": "DoesNotExist"}],
+        "tools": [{"name": "DoesNotExist", "module": "crewai_tools",}],
     }
     mock_get_agent.return_value = mock_get_response
     with pytest.raises(
@@ -2120,3 +2126,60 @@ def test_agent_from_repository_agent_not_found(mock_get_agent, mock_get_auth_tok
         match="Agent test_agent does not exist, make sure the name is correct or the agent is available on your organization",
     ):
         Agent(from_repository="test_agent")
+
+
+@patch("crewai.cli.plus_api.PlusAPI.get_agent")
+@patch("crewai.utilities.agent_utils.Settings")
+@patch("crewai.utilities.agent_utils.console")
+def test_agent_from_repository_displays_org_info(mock_console, mock_settings, mock_get_agent, mock_get_auth_token):
+    mock_settings_instance = MagicMock()
+    mock_settings_instance.org_uuid = "test-org-uuid"
+    mock_settings_instance.org_name = "Test Organization"
+    mock_settings.return_value = mock_settings_instance
+
+    mock_get_response = MagicMock()
+    mock_get_response.status_code = 200
+    mock_get_response.json.return_value = {
+        "role": "test role",
+        "goal": "test goal",
+        "backstory": "test backstory",
+        "tools": []
+    }
+    mock_get_agent.return_value = mock_get_response
+
+    agent = Agent(from_repository="test_agent")
+
+    mock_console.print.assert_any_call(
+        "Fetching agent from organization: Test Organization (test-org-uuid)",
+        style="bold blue"
+    )
+
+    assert agent.role == "test role"
+    assert agent.goal == "test goal"
+    assert agent.backstory == "test backstory"
+
+
+@patch("crewai.cli.plus_api.PlusAPI.get_agent")
+@patch("crewai.utilities.agent_utils.Settings")
+@patch("crewai.utilities.agent_utils.console")
+def test_agent_from_repository_without_org_set(mock_console, mock_settings, mock_get_agent, mock_get_auth_token):
+    mock_settings_instance = MagicMock()
+    mock_settings_instance.org_uuid = None
+    mock_settings_instance.org_name = None
+    mock_settings.return_value = mock_settings_instance
+
+    mock_get_response = MagicMock()
+    mock_get_response.status_code = 401
+    mock_get_response.text = "Unauthorized access"
+    mock_get_agent.return_value = mock_get_response
+
+    with pytest.raises(
+        AgentRepositoryError,
+        match="Agent test_agent could not be loaded: Unauthorized access"
+    ):
+        Agent(from_repository="test_agent")
+
+    mock_console.print.assert_any_call(
+        "No organization currently set. We recommend setting one before using: `crewai org switch <org_id>` command.",
+        style="yellow"
+    )

tests/cli/deploy/test_deploy_main.py

@@ -231,7 +231,7 @@ class TestDeployCommand(unittest.TestCase):
         [project]
         name = "test_project"
         version = "0.1.0"
-        requires-python = ">=3.10,<3.13"
+        requires-python = ">=3.10,<3.14"
         dependencies = ["crewai"]
         """,
     )
@@ -250,7 +250,7 @@ class TestDeployCommand(unittest.TestCase):
     [project]
     name = "test_project"
     version = "0.1.0"
-    requires-python = ">=3.10,<3.13"
+    requires-python = ">=3.10,<3.14"
     dependencies = ["crewai"]
     """,
     )

tests/cli/organization/__init__.py

@@ -0,0 +1 @@
+

tests/cli/organization/test_main.py

@@ -0,0 +1,244 @@
+import unittest
+from unittest.mock import MagicMock, patch, call
+
+import pytest
+from click.testing import CliRunner
+import requests
+
+from crewai.cli.organization.main import OrganizationCommand
+from crewai.cli.cli import list, switch, current
+
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+
+@pytest.fixture
+def org_command():
+    with patch.object(OrganizationCommand, '__init__', return_value=None):
+        command = OrganizationCommand()
+        yield command
+
+
+@pytest.fixture
+def mock_settings():
+    with patch('crewai.cli.organization.main.Settings') as mock_settings_class:
+        mock_settings_instance = MagicMock()
+        mock_settings_class.return_value = mock_settings_instance
+        yield mock_settings_instance
+
+
+@patch('crewai.cli.cli.OrganizationCommand')
+def test_org_list_command(mock_org_command_class, runner):
+    mock_org_instance = MagicMock()
+    mock_org_command_class.return_value = mock_org_instance
+
+    result = runner.invoke(list)
+
+    assert result.exit_code == 0
+    mock_org_command_class.assert_called_once()
+    mock_org_instance.list.assert_called_once()
+
+
+@patch('crewai.cli.cli.OrganizationCommand')
+def test_org_switch_command(mock_org_command_class, runner):
+    mock_org_instance = MagicMock()
+    mock_org_command_class.return_value = mock_org_instance
+
+    result = runner.invoke(switch, ['test-id'])
+
+    assert result.exit_code == 0
+    mock_org_command_class.assert_called_once()
+    mock_org_instance.switch.assert_called_once_with('test-id')
+
+
+@patch('crewai.cli.cli.OrganizationCommand')
+def test_org_current_command(mock_org_command_class, runner):
+    mock_org_instance = MagicMock()
+    mock_org_command_class.return_value = mock_org_instance
+
+    result = runner.invoke(current)
+
+    assert result.exit_code == 0
+    mock_org_command_class.assert_called_once()
+    mock_org_instance.current.assert_called_once()
+
+
+class TestOrganizationCommand(unittest.TestCase):
+    def setUp(self):
+        with patch.object(OrganizationCommand, '__init__', return_value=None):
+            self.org_command = OrganizationCommand()
+            self.org_command.plus_api_client = MagicMock()
+
+    @patch('crewai.cli.organization.main.console')
+    @patch('crewai.cli.organization.main.Table')
+    def test_list_organizations_success(self, mock_table, mock_console):
+        mock_response = MagicMock()
+        mock_response.raise_for_status = MagicMock()
+        mock_response.json.return_value = [
+            {"name": "Org 1", "uuid": "org-123"},
+            {"name": "Org 2", "uuid": "org-456"}
+        ]
+        self.org_command.plus_api_client = MagicMock()
+        self.org_command.plus_api_client.get_organizations.return_value = mock_response
+
+        mock_console.print = MagicMock()
+
+        self.org_command.list()
+
+        self.org_command.plus_api_client.get_organizations.assert_called_once()
+        mock_table.assert_called_once_with(title="Your Organizations")
+        mock_table.return_value.add_column.assert_has_calls([
+            call("Name", style="cyan"),
+            call("ID", style="green")
+        ])
+        mock_table.return_value.add_row.assert_has_calls([
+            call("Org 1", "org-123"),
+            call("Org 2", "org-456")
+        ])
+
+    @patch('crewai.cli.organization.main.console')
+    def test_list_organizations_empty(self, mock_console):
+        mock_response = MagicMock()
+        mock_response.raise_for_status = MagicMock()
+        mock_response.json.return_value = []
+        self.org_command.plus_api_client = MagicMock()
+        self.org_command.plus_api_client.get_organizations.return_value = mock_response
+
+        self.org_command.list()
+
+        self.org_command.plus_api_client.get_organizations.assert_called_once()
+        mock_console.print.assert_called_once_with(
+            "You don't belong to any organizations yet.",
+            style="yellow"
+        )
+
+    @patch('crewai.cli.organization.main.console')
+    def test_list_organizations_api_error(self, mock_console):
+        self.org_command.plus_api_client = MagicMock()
+        self.org_command.plus_api_client.get_organizations.side_effect = requests.exceptions.RequestException("API Error")
+
+        with pytest.raises(SystemExit):
+            self.org_command.list()
+
+
+        self.org_command.plus_api_client.get_organizations.assert_called_once()
+        mock_console.print.assert_called_once_with(
+            "Failed to retrieve organization list: API Error",
+            style="bold red"
+        )
+
+    @patch('crewai.cli.organization.main.console')
+    @patch('crewai.cli.organization.main.Settings')
+    def test_switch_organization_success(self, mock_settings_class, mock_console):
+        mock_response = MagicMock()
+        mock_response.raise_for_status = MagicMock()
+        mock_response.json.return_value = [
+            {"name": "Org 1", "uuid": "org-123"},
+            {"name": "Test Org", "uuid": "test-id"}
+        ]
+        self.org_command.plus_api_client = MagicMock()
+        self.org_command.plus_api_client.get_organizations.return_value = mock_response
+
+        mock_settings_instance = MagicMock()
+        mock_settings_class.return_value = mock_settings_instance
+
+        self.org_command.switch("test-id")
+
+        self.org_command.plus_api_client.get_organizations.assert_called_once()
+        mock_settings_instance.dump.assert_called_once()
+        assert mock_settings_instance.org_name == "Test Org"
+        assert mock_settings_instance.org_uuid == "test-id"
+        mock_console.print.assert_called_once_with(
+            "Successfully switched to Test Org (test-id)",
+            style="bold green"
+        )
+
+    @patch('crewai.cli.organization.main.console')
+    def test_switch_organization_not_found(self, mock_console):
+        mock_response = MagicMock()
+        mock_response.raise_for_status = MagicMock()
+        mock_response.json.return_value = [
+            {"name": "Org 1", "uuid": "org-123"},
+            {"name": "Org 2", "uuid": "org-456"}
+        ]
+        self.org_command.plus_api_client = MagicMock()
+        self.org_command.plus_api_client.get_organizations.return_value = mock_response
+
+        self.org_command.switch("non-existent-id")
+
+        self.org_command.plus_api_client.get_organizations.assert_called_once()
+        mock_console.print.assert_called_once_with(
+            "Organization with id 'non-existent-id' not found.",
+            style="bold red"
+        )
+
+    @patch('crewai.cli.organization.main.console')
+    @patch('crewai.cli.organization.main.Settings')
+    def test_current_organization_with_org(self, mock_settings_class, mock_console):
+        mock_settings_instance = MagicMock()
+        mock_settings_instance.org_name = "Test Org"
+        mock_settings_instance.org_uuid = "test-id"
+        mock_settings_class.return_value = mock_settings_instance
+
+        self.org_command.current()
+
+        self.org_command.plus_api_client.get_organizations.assert_not_called()
+        mock_console.print.assert_called_once_with(
+            "Currently logged in to organization Test Org (test-id)",
+            style="bold green"
+        )
+
+    @patch('crewai.cli.organization.main.console')
+    @patch('crewai.cli.organization.main.Settings')
+    def test_current_organization_without_org(self, mock_settings_class, mock_console):
+        mock_settings_instance = MagicMock()
+        mock_settings_instance.org_uuid = None
+        mock_settings_class.return_value = mock_settings_instance
+
+        self.org_command.current()
+
+        assert mock_console.print.call_count == 3
+        mock_console.print.assert_any_call(
+            "You're not currently logged in to any organization.",
+            style="yellow"
+        )
+
+    @patch('crewai.cli.organization.main.console')
+    def test_list_organizations_unauthorized(self, mock_console):
+        mock_response = MagicMock()
+        mock_http_error = requests.exceptions.HTTPError(
+            "401 Client Error: Unauthorized",
+            response=MagicMock(status_code=401)
+        )
+
+        mock_response.raise_for_status.side_effect = mock_http_error
+        self.org_command.plus_api_client.get_organizations.return_value = mock_response
+
+        self.org_command.list()
+
+        self.org_command.plus_api_client.get_organizations.assert_called_once()
+        mock_console.print.assert_called_once_with(
+            "You are not logged in to any organization. Use 'crewai login' to login.",
+            style="bold red"
+        )
+
+    @patch('crewai.cli.organization.main.console')
+    def test_switch_organization_unauthorized(self, mock_console):
+        mock_response = MagicMock()
+        mock_http_error = requests.exceptions.HTTPError(
+            "401 Client Error: Unauthorized",
+            response=MagicMock(status_code=401)
+        )
+
+        mock_response.raise_for_status.side_effect = mock_http_error
+        self.org_command.plus_api_client.get_organizations.return_value = mock_response
+
+        self.org_command.switch("test-id")
+
+        self.org_command.plus_api_client.get_organizations.assert_called_once()
+        mock_console.print.assert_called_once_with(
+            "You are not logged in to any organization. Use 'crewai login' to login.",
+            style="bold red"
+        )

tests/cli/test_plus_api.py

@@ -1,6 +1,6 @@
 import os
 import unittest
-from unittest.mock import MagicMock, patch
+from unittest.mock import MagicMock, patch, ANY
 
 from crewai.cli.plus_api import PlusAPI
 
@@ -9,6 +9,7 @@ class TestPlusAPI(unittest.TestCase):
     def setUp(self):
         self.api_key = "test_api_key"
         self.api = PlusAPI(self.api_key)
+        self.org_uuid = "test-org-uuid"
 
     def test_init(self):
         self.assertEqual(self.api.api_key, self.api_key)
@@ -29,17 +30,96 @@ class TestPlusAPI(unittest.TestCase):
         )
         self.assertEqual(response, mock_response)
 
+    def assert_request_with_org_id(self, mock_make_request, method: str, endpoint: str, **kwargs):
+        mock_make_request.assert_called_once_with(
+            method, f"https://app.crewai.com{endpoint}", headers={'Authorization': ANY, 'Content-Type': ANY, 'User-Agent':  ANY, 'X-Crewai-Version': ANY, 'X-Crewai-Organization-Id': self.org_uuid}, **kwargs
+        )
+
+    @patch("crewai.cli.plus_api.Settings")
+    @patch("requests.Session.request")
+    def test_login_to_tool_repository_with_org_uuid(self, mock_make_request, mock_settings_class):
+        mock_settings = MagicMock()
+        mock_settings.org_uuid = self.org_uuid
+        mock_settings_class.return_value = mock_settings
+        # re-initialize Client
+        self.api = PlusAPI(self.api_key)
+        
+        mock_response = MagicMock()
+        mock_make_request.return_value = mock_response
+
+        response = self.api.login_to_tool_repository()
+
+        self.assert_request_with_org_id(
+            mock_make_request,
+            'POST',
+            '/crewai_plus/api/v1/tools/login'
+        )
+        self.assertEqual(response, mock_response)
+
+    @patch("crewai.cli.plus_api.PlusAPI._make_request")
+    def test_get_agent(self, mock_make_request):
+        mock_response = MagicMock()
+        mock_make_request.return_value = mock_response
+
+        response = self.api.get_agent("test_agent_handle")
+        mock_make_request.assert_called_once_with(
+            "GET", "/crewai_plus/api/v1/agents/test_agent_handle"
+        )
+        self.assertEqual(response, mock_response)
+        
+    @patch("crewai.cli.plus_api.Settings")
+    @patch("requests.Session.request")
+    def test_get_agent_with_org_uuid(self, mock_make_request, mock_settings_class):
+        mock_settings = MagicMock()
+        mock_settings.org_uuid = self.org_uuid
+        mock_settings_class.return_value = mock_settings
+        # re-initialize Client
+        self.api = PlusAPI(self.api_key)
+        
+        mock_response = MagicMock()
+        mock_make_request.return_value = mock_response
+
+        response = self.api.get_agent("test_agent_handle")
+
+        self.assert_request_with_org_id(
+            mock_make_request,
+            "GET",
+            "/crewai_plus/api/v1/agents/test_agent_handle"
+        )
+        self.assertEqual(response, mock_response)
+    
     @patch("crewai.cli.plus_api.PlusAPI._make_request")
     def test_get_tool(self, mock_make_request):
         mock_response = MagicMock()
         mock_make_request.return_value = mock_response
 
         response = self.api.get_tool("test_tool_handle")
-
         mock_make_request.assert_called_once_with(
             "GET", "/crewai_plus/api/v1/tools/test_tool_handle"
         )
         self.assertEqual(response, mock_response)
+        
+    @patch("crewai.cli.plus_api.Settings")
+    @patch("requests.Session.request")
+    def test_get_tool_with_org_uuid(self, mock_make_request, mock_settings_class):
+        mock_settings = MagicMock()
+        mock_settings.org_uuid = self.org_uuid
+        mock_settings_class.return_value = mock_settings
+        # re-initialize Client
+        self.api = PlusAPI(self.api_key)
+
+        # Set up mock response
+        mock_response = MagicMock()
+        mock_make_request.return_value = mock_response
+
+        response = self.api.get_tool("test_tool_handle")
+
+        self.assert_request_with_org_id(
+            mock_make_request,
+            "GET",
+            "/crewai_plus/api/v1/tools/test_tool_handle"
+        )
+        self.assertEqual(response, mock_response)
 
     @patch("crewai.cli.plus_api.PlusAPI._make_request")
     def test_publish_tool(self, mock_make_request):
@@ -67,6 +147,47 @@ class TestPlusAPI(unittest.TestCase):
             "POST", "/crewai_plus/api/v1/tools", json=params
         )
         self.assertEqual(response, mock_response)
+        
+    @patch("crewai.cli.plus_api.Settings")
+    @patch("requests.Session.request")
+    def test_publish_tool_with_org_uuid(self, mock_make_request, mock_settings_class):
+        mock_settings = MagicMock()
+        mock_settings.org_uuid = self.org_uuid
+        mock_settings_class.return_value = mock_settings
+        # re-initialize Client
+        self.api = PlusAPI(self.api_key)
+
+        # Set up mock response
+        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"
+
+        response = self.api.publish_tool(
+            handle, public, version, description, encoded_file
+        )
+
+        # Expected params including organization_uuid
+        expected_params = {
+            "handle": handle,
+            "public": public,
+            "version": version,
+            "file": encoded_file,
+            "description": description,
+            "available_exports": None,
+        }
+        
+        self.assert_request_with_org_id(
+            mock_make_request,
+            "POST",
+            "/crewai_plus/api/v1/tools",
+            json=expected_params
+        )
+        self.assertEqual(response, mock_response)
 
     @patch("crewai.cli.plus_api.PlusAPI._make_request")
     def test_publish_tool_without_description(self, mock_make_request):

tests/cli/tools/test_main.py

@@ -56,7 +56,8 @@ def test_create_success(mock_subprocess, capsys, tool_command):
 
 @patch("crewai.cli.tools.main.subprocess.run")
 @patch("crewai.cli.plus_api.PlusAPI.get_tool")
-def test_install_success(mock_get, mock_subprocess_run, capsys, tool_command):
+@patch("crewai.cli.tools.main.ToolCommand._print_current_organization")
+def test_install_success(mock_print_org, mock_get, mock_subprocess_run, capsys, tool_command):
     mock_get_response = MagicMock()
     mock_get_response.status_code = 200
     mock_get_response.json.return_value = {
@@ -85,6 +86,9 @@ def test_install_success(mock_get, mock_subprocess_run, capsys, tool_command):
         env=unittest.mock.ANY,
     )
 
+    # Verify _print_current_organization was called
+    mock_print_org.assert_called_once()
+
 @patch("crewai.cli.tools.main.subprocess.run")
 @patch("crewai.cli.plus_api.PlusAPI.get_tool")
 def test_install_success_from_pypi(mock_get, mock_subprocess_run, capsys, tool_command):
@@ -165,8 +169,10 @@ def test_publish_when_not_in_sync(mock_is_synced, capsys, tool_command):
 )
 @patch("crewai.cli.plus_api.PlusAPI.publish_tool")
 @patch("crewai.cli.tools.main.git.Repository.is_synced", return_value=False)
-@patch("crewai.cli.tools.main.extract_available_exports", return_value=["SampleTool"])
+@patch("crewai.cli.tools.main.extract_available_exports", return_value=[{"name": "SampleTool"}])
+@patch("crewai.cli.tools.main.ToolCommand._print_current_organization")
 def test_publish_when_not_in_sync_and_force(
+    mock_print_org,
     mock_available_exports,
     mock_is_synced,
     mock_publish,
@@ -200,8 +206,9 @@ def test_publish_when_not_in_sync_and_force(
         version="1.0.0",
         description="A sample tool",
         encoded_file=unittest.mock.ANY,
-        available_exports=["SampleTool"],
+        available_exports=[{"name": "SampleTool"}],
     )
+    mock_print_org.assert_called_once()
 
 
 @patch("crewai.cli.tools.main.get_project_name", return_value="sample-tool")
@@ -216,7 +223,7 @@ def test_publish_when_not_in_sync_and_force(
 )
 @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=["SampleTool"])
+@patch("crewai.cli.tools.main.extract_available_exports", return_value=[{"name": "SampleTool"}])
 def test_publish_success(
     mock_available_exports,
     mock_is_synced,
@@ -251,7 +258,7 @@ def test_publish_success(
         version="1.0.0",
         description="A sample tool",
         encoded_file=unittest.mock.ANY,
-        available_exports=["SampleTool"],
+        available_exports=[{"name": "SampleTool"}],
     )
 
 
@@ -266,7 +273,7 @@ def test_publish_success(
     read_data=b"sample tarball content",
 )
 @patch("crewai.cli.plus_api.PlusAPI.publish_tool")
-@patch("crewai.cli.tools.main.extract_available_exports", return_value=["SampleTool"])
+@patch("crewai.cli.tools.main.extract_available_exports", return_value=[{"name": "SampleTool"}])
 def test_publish_failure(
     mock_available_exports,
     mock_publish,
@@ -304,7 +311,7 @@ def test_publish_failure(
     read_data=b"sample tarball content",
 )
 @patch("crewai.cli.plus_api.PlusAPI.publish_tool")
-@patch("crewai.cli.tools.main.extract_available_exports", return_value=["SampleTool"])
+@patch("crewai.cli.tools.main.extract_available_exports", return_value=[{"name": "SampleTool"}])
 def test_publish_api_error(
     mock_available_exports,
     mock_publish,
@@ -329,3 +336,27 @@ def test_publish_api_error(
     assert "Request to Enterprise API failed" in output
 
     mock_publish.assert_called_once()
+
+
+
+@patch("crewai.cli.tools.main.Settings")
+def test_print_current_organization_with_org(mock_settings, capsys, tool_command):
+    mock_settings_instance = MagicMock()
+    mock_settings_instance.org_uuid = "test-org-uuid"
+    mock_settings_instance.org_name = "Test Organization"
+    mock_settings.return_value = mock_settings_instance
+    tool_command._print_current_organization()
+    output = capsys.readouterr().out
+    assert "Current organization: Test Organization (test-org-uuid)" in output
+
+
+@patch("crewai.cli.tools.main.Settings")
+def test_print_current_organization_without_org(mock_settings, capsys, tool_command):
+    mock_settings_instance = MagicMock()
+    mock_settings_instance.org_uuid = None
+    mock_settings_instance.org_name = None
+    mock_settings.return_value = mock_settings_instance
+    tool_command._print_current_organization()
+    output = capsys.readouterr().out
+    assert "No organization currently set" in output
+    assert "org switch <org_id>" in output

tests/crew_test.py

@@ -1765,6 +1765,50 @@ def test_agent_usage_metrics_are_captured_for_hierarchical_process():
     )
 
 
+def test_hierarchical_kickoff_usage_metrics_include_manager(researcher):
+    """Ensure Crew.kickoff() sums UsageMetrics from both regular and manager agents."""
+
+    # ── 1.  Build the manager and a simple task ──────────────────────────────────
+    manager = Agent(
+        role="Manager",
+        goal="Coordinate everything.",
+        backstory="Keeps the project on track.",
+        allow_delegation=False,
+    )
+
+    task = Task(
+        description="Say hello",
+        expected_output="Hello",
+        agent=researcher,  # *regular* agent
+    )
+
+    # ── 2.  Stub out each agent’s _token_process.get_summary() ───────────────────
+    researcher_metrics = UsageMetrics(total_tokens=120, prompt_tokens=80, completion_tokens=40, successful_requests=2)
+    manager_metrics = UsageMetrics(total_tokens=30, prompt_tokens=20, completion_tokens=10, successful_requests=1)
+
+    # Replace the internal _token_process objects with simple mocks
+    researcher._token_process = MagicMock(get_summary=MagicMock(return_value=researcher_metrics))
+    manager._token_process = MagicMock(get_summary=MagicMock(return_value=manager_metrics))
+
+    # ── 3.  Create the crew (hierarchical!) and kick it off ──────────────────────
+    crew = Crew(
+        agents=[researcher],  # regular agents
+        manager_agent=manager,  # manager to be included
+        tasks=[task],
+        process=Process.hierarchical,
+    )
+
+    # We don’t care about LLM output here; patch execute_sync to avoid network
+    with patch.object(Task, "execute_sync", return_value=TaskOutput(description="dummy", raw="Hello", agent=researcher.role)):
+        crew.kickoff()
+
+    # ── 4.  Assert the aggregated numbers are the *sum* of both agents ───────────
+    assert crew.usage_metrics.total_tokens == researcher_metrics.total_tokens + manager_metrics.total_tokens
+    assert crew.usage_metrics.prompt_tokens == researcher_metrics.prompt_tokens + manager_metrics.prompt_tokens
+    assert crew.usage_metrics.completion_tokens == researcher_metrics.completion_tokens + manager_metrics.completion_tokens
+    assert crew.usage_metrics.successful_requests == researcher_metrics.successful_requests + manager_metrics.successful_requests
+
+
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_hierarchical_crew_creation_tasks_with_agents(researcher, writer):
     """
@@ -4564,5 +4608,3 @@ def test_reset_agent_knowledge_with_only_agent_knowledge(researcher,writer):
 
         crew.reset_memories(command_type='agent_knowledge')
         mock_reset_agent_knowledge.assert_called_once_with([mock_ks_research,mock_ks_writer])
-
-

tests/tools/test_structured_tool.py

@@ -25,122 +25,206 @@ def schema_class():
     return TestSchema
 
 
-class InternalCrewStructuredTool:
-    def test_initialization(self, basic_function, schema_class):
-        """Test basic initialization of CrewStructuredTool"""
-        tool = CrewStructuredTool(
-            name="test_tool",
-            description="Test tool description",
-            func=basic_function,
-            args_schema=schema_class,
-        )
+def test_initialization(basic_function, schema_class):
+    """Test basic initialization of CrewStructuredTool"""
+    tool = CrewStructuredTool(
+        name="test_tool",
+        description="Test tool description",
+        func=basic_function,
+        args_schema=schema_class,
+    )
 
-        assert tool.name == "test_tool"
-        assert tool.description == "Test tool description"
-        assert tool.func == basic_function
-        assert tool.args_schema == schema_class
+    assert tool.name == "test_tool"
+    assert tool.description == "Test tool description"
+    assert tool.func == basic_function
+    assert tool.args_schema == schema_class
 
-    def test_from_function(self, basic_function):
-        """Test creating tool from function"""
-        tool = CrewStructuredTool.from_function(
-            func=basic_function, name="test_tool", description="Test description"
-        )
+def test_from_function(basic_function):
+    """Test creating tool from function"""
+    tool = CrewStructuredTool.from_function(
+        func=basic_function, name="test_tool", description="Test description"
+    )
 
-        assert tool.name == "test_tool"
-        assert tool.description == "Test description"
-        assert tool.func == basic_function
-        assert isinstance(tool.args_schema, type(BaseModel))
+    assert tool.name == "test_tool"
+    assert tool.description == "Test description"
+    assert tool.func == basic_function
+    assert isinstance(tool.args_schema, type(BaseModel))
 
-    def test_validate_function_signature(self, basic_function, schema_class):
-        """Test function signature validation"""
-        tool = CrewStructuredTool(
-            name="test_tool",
-            description="Test tool",
-            func=basic_function,
-            args_schema=schema_class,
-        )
+def test_validate_function_signature(basic_function, schema_class):
+    """Test function signature validation"""
+    tool = CrewStructuredTool(
+        name="test_tool",
+        description="Test tool",
+        func=basic_function,
+        args_schema=schema_class,
+    )
 
-        # Should not raise any exceptions
-        tool._validate_function_signature()
+    # Should not raise any exceptions
+    tool._validate_function_signature()
 
-    @pytest.mark.asyncio
-    async def test_ainvoke(self, basic_function):
-        """Test asynchronous invocation"""
-        tool = CrewStructuredTool.from_function(func=basic_function, name="test_tool")
+@pytest.mark.asyncio
+async def test_ainvoke(basic_function):
+    """Test asynchronous invocation"""
+    tool = CrewStructuredTool.from_function(func=basic_function, name="test_tool")
 
-        result = await tool.ainvoke(input={"param1": "test"})
-        assert result == "test 0"
+    result = await tool.ainvoke(input={"param1": "test"})
+    assert result == "test 0"
 
-    def test_parse_args_dict(self, basic_function):
-        """Test parsing dictionary arguments"""
-        tool = CrewStructuredTool.from_function(func=basic_function, name="test_tool")
+def test_parse_args_dict(basic_function):
+    """Test parsing dictionary arguments"""
+    tool = CrewStructuredTool.from_function(func=basic_function, name="test_tool")
 
-        parsed = tool._parse_args({"param1": "test", "param2": 42})
-        assert parsed["param1"] == "test"
-        assert parsed["param2"] == 42
+    parsed = tool._parse_args({"param1": "test", "param2": 42})
+    assert parsed["param1"] == "test"
+    assert parsed["param2"] == 42
 
-    def test_parse_args_string(self, basic_function):
-        """Test parsing string arguments"""
-        tool = CrewStructuredTool.from_function(func=basic_function, name="test_tool")
+def test_parse_args_string(basic_function):
+    """Test parsing string arguments"""
+    tool = CrewStructuredTool.from_function(func=basic_function, name="test_tool")
 
-        parsed = tool._parse_args('{"param1": "test", "param2": 42}')
-        assert parsed["param1"] == "test"
-        assert parsed["param2"] == 42
+    parsed = tool._parse_args('{"param1": "test", "param2": 42}')
+    assert parsed["param1"] == "test"
+    assert parsed["param2"] == 42
 
-    def test_complex_types(self):
-        """Test handling of complex parameter types"""
+def test_complex_types():
+    """Test handling of complex parameter types"""
 
-        def complex_func(nested: dict, items: list) -> str:
-            """Process complex types."""
-            return f"Processed {len(items)} items with {len(nested)} nested keys"
+    def complex_func(nested: dict, items: list) -> str:
+        """Process complex types."""
+        return f"Processed {len(items)} items with {len(nested)} nested keys"
 
-        tool = CrewStructuredTool.from_function(
-            func=complex_func, name="test_tool", description="Test complex types"
-        )
-        result = tool.invoke({"nested": {"key": "value"}, "items": [1, 2, 3]})
-        assert result == "Processed 3 items with 1 nested keys"
+    tool = CrewStructuredTool.from_function(
+        func=complex_func, name="test_tool", description="Test complex types"
+    )
+    result = tool.invoke({"nested": {"key": "value"}, "items": [1, 2, 3]})
+    assert result == "Processed 3 items with 1 nested keys"
 
-    def test_schema_inheritance(self):
-        """Test tool creation with inherited schema"""
+def test_schema_inheritance():
+    """Test tool creation with inherited schema"""
 
-        def extended_func(base_param: str, extra_param: int) -> str:
-            """Test function with inherited schema."""
-            return f"{base_param} {extra_param}"
+    def extended_func(base_param: str, extra_param: int) -> str:
+        """Test function with inherited schema."""
+        return f"{base_param} {extra_param}"
 
-        class BaseSchema(BaseModel):
-            base_param: str
+    class BaseSchema(BaseModel):
+        base_param: str
 
-        class ExtendedSchema(BaseSchema):
-            extra_param: int
+    class ExtendedSchema(BaseSchema):
+        extra_param: int
 
-        tool = CrewStructuredTool.from_function(
-            func=extended_func, name="test_tool", args_schema=ExtendedSchema
-        )
+    tool = CrewStructuredTool.from_function(
+        func=extended_func, name="test_tool", args_schema=ExtendedSchema
+    )
 
-        result = tool.invoke({"base_param": "test", "extra_param": 42})
-        assert result == "test 42"
+    result = tool.invoke({"base_param": "test", "extra_param": 42})
+    assert result == "test 42"
 
-    def test_default_values_in_schema(self):
-        """Test handling of default values in schema"""
+def test_default_values_in_schema():
+    """Test handling of default values in schema"""
 
-        def default_func(
-            required_param: str,
-            optional_param: str = "default",
-            nullable_param: Optional[int] = None,
-        ) -> str:
-            """Test function with default values."""
-            return f"{required_param} {optional_param} {nullable_param}"
+    def default_func(
+        required_param: str,
+        optional_param: str = "default",
+        nullable_param: Optional[int] = None,
+    ) -> str:
+        """Test function with default values."""
+        return f"{required_param} {optional_param} {nullable_param}"
 
-        tool = CrewStructuredTool.from_function(
-            func=default_func, name="test_tool", description="Test defaults"
-        )
+    tool = CrewStructuredTool.from_function(
+        func=default_func, name="test_tool", description="Test defaults"
+    )
 
-        # Test with minimal parameters
-        result = tool.invoke({"required_param": "test"})
-        assert result == "test default None"
+    # Test with minimal parameters
+    result = tool.invoke({"required_param": "test"})
+    assert result == "test default None"
 
-        # Test with all parameters
-        result = tool.invoke(
-            {"required_param": "test", "optional_param": "custom", "nullable_param": 42}
-        )
-        assert result == "test custom 42"
+    # Test with all parameters
+    result = tool.invoke(
+        {"required_param": "test", "optional_param": "custom", "nullable_param": 42}
+    )
+    assert result == "test custom 42"
+
+@pytest.fixture
+def custom_tool_decorator():
+    from crewai.tools import tool
+
+    @tool("custom_tool", result_as_answer=True)
+    async def custom_tool():
+        """This is a tool that does something"""
+        return "Hello World from Custom Tool"
+
+    return custom_tool
+
+@pytest.fixture
+def custom_tool():
+    from crewai.tools import BaseTool
+
+    class CustomTool(BaseTool):
+        name: str = "my_tool"
+        description: str = "This is a tool that does something"
+        result_as_answer: bool = True
+
+        async def _run(self):
+            return "Hello World from Custom Tool"
+
+    return CustomTool()
+
+def build_simple_crew(tool):
+    from crewai import Agent, Task, Crew
+
+    agent1 = Agent(role="Simple role", goal="Simple goal", backstory="Simple backstory", tools=[tool])
+
+    say_hi_task = Task(
+        description="Use the custom tool result as answer.", agent=agent1, expected_output="Use the tool result"
+    )
+
+    crew = Crew(agents=[agent1], tasks=[say_hi_task])
+    return crew
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_async_tool_using_within_isolated_crew(custom_tool):
+    crew = build_simple_crew(custom_tool)
+    result = crew.kickoff()
+
+    assert result.raw == "Hello World from Custom Tool"
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_async_tool_using_decorator_within_isolated_crew(custom_tool_decorator):
+    crew = build_simple_crew(custom_tool_decorator)
+    result = crew.kickoff()
+
+    assert result.raw == "Hello World from Custom Tool"
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_async_tool_within_flow(custom_tool):
+    from crewai.flow.flow import Flow
+
+    class StructuredExampleFlow(Flow):
+        from crewai.flow.flow import start
+
+        @start()
+        async def start(self):
+            crew = build_simple_crew(custom_tool)
+            result = await crew.kickoff_async()
+            return result
+
+    flow = StructuredExampleFlow()
+    result = flow.kickoff()
+    assert result.raw == "Hello World from Custom Tool"
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_async_tool_using_decorator_within_flow(custom_tool_decorator):
+    from crewai.flow.flow import Flow
+
+    class StructuredExampleFlow(Flow):
+        from crewai.flow.flow import start
+        @start()
+        async def start(self):
+            crew = build_simple_crew(custom_tool_decorator)
+            result = await crew.kickoff_async()
+            return result
+
+    flow = StructuredExampleFlow()
+    result = flow.kickoff()
+    assert result.raw == "Hello World from Custom Tool"