π OpenHands: AI-Driven Development
feat(backend): API to get the microagents for the selected repository. (#9749)
Hiep Leeecc00fa4adf
diff --git a/openhands/integrations/provider.py b/openhands/integrations/provider.pyindex 98a87fc9f3..317afd6a50 100644--- a/openhands/integrations/provider.py+++ b/openhands/integrations/provider.py@@ -95,6 +95,13 @@ CUSTOM_SECRETS_TYPE_WITH_JSON_SCHEMA = Annotated[class ProviderHandler:+ # Class variable for provider domains+ PROVIDER_DOMAINS: dict[ProviderType, str] = {+ ProviderType.GITHUB: 'github.com',+ ProviderType.GITLAB: 'gitlab.com',+ ProviderType.BITBUCKET: 'bitbucket.org',+ }+def __init__(self,provider_tokens: PROVIDER_TOKEN_TYPE,@@ -399,3 +406,53 @@ class ProviderHandler:other_branches.append(branch)return main_branches + other_branches++ async def get_authenticated_git_url(self, repo_name: str) -> str:+ """Get an authenticated git URL for a repository.++ Args:+ repo_name: Repository name (owner/repo)++ Returns:+ Authenticated git URL if credentials are available, otherwise regular HTTPS URL+ """+ try:+ repository = await self.verify_repo_provider(repo_name)+ except AuthenticationError:+ raise Exception('Git provider authentication issue when getting remote URL')++ provider = repository.git_provider+ repo_name = repository.full_name++ domain = self.PROVIDER_DOMAINS[provider]++ # If provider tokens are provided, use the host from the token if available+ if self.provider_tokens and provider in self.provider_tokens:+ domain = self.provider_tokens[provider].host or domain++ # Try to use token if available, otherwise use public URL+ if self.provider_tokens and provider in self.provider_tokens:+ git_token = self.provider_tokens[provider].token+ if git_token:+ token_value = git_token.get_secret_value()+ if provider == ProviderType.GITLAB:+ remote_url = (+ f'https://oauth2:{token_value}@{domain}/{repo_name}.git'+ )+ elif provider == ProviderType.BITBUCKET:+ # For Bitbucket, handle username:app_password format+ if ':' in token_value:+ # App token format: username:app_password+ remote_url = f'https://{token_value}@{domain}/{repo_name}.git'+ else:+ # Access token format: use x-token-auth+ remote_url = f'https://x-token-auth:{token_value}@{domain}/{repo_name}.git'+ else:+ # GitHub+ remote_url = f'https://{token_value}@{domain}/{repo_name}.git'+ else:+ remote_url = f'https://{domain}/{repo_name}.git'+ else:+ remote_url = f'https://{domain}/{repo_name}.git'++ return remote_urldiff --git a/openhands/runtime/base.py b/openhands/runtime/base.pyindex 1729160e4c..084ec208cb 100644--- a/openhands/runtime/base.py+++ b/openhands/runtime/base.py@@ -49,7 +49,6 @@ from openhands.integrations.provider import (ProviderHandler,ProviderType,)-from openhands.integrations.service_types import AuthenticationErrorfrom openhands.microagent import (BaseMicroagent,load_microagents_from_dir,@@ -381,8 +380,8 @@ class Runtime(FileEditRuntimeMixin):)return ''- remote_repo_url = await self._get_authenticated_git_url(- selected_repository, git_provider_tokens+ remote_repo_url = await self.provider_handler.get_authenticated_git_url(+ selected_repository)if not remote_repo_url:@@ -601,68 +600,6 @@ fireturn loaded_microagents- async def _get_authenticated_git_url(- self, repo_name: str, git_provider_tokens: PROVIDER_TOKEN_TYPE | None- ) -> str:- """Get an authenticated git URL for a repository.-- Args:- repo_path: Repository name (owner/repo)-- Returns:- Authenticated git URL if credentials are available, otherwise regular HTTPS URL- """-- try:- provider_handler = ProviderHandler(- git_provider_tokens or MappingProxyType({})- )- repository = await provider_handler.verify_repo_provider(repo_name)- except AuthenticationError:- raise Exception('Git provider authentication issue when getting remote URL')-- provider = repository.git_provider- repo_name = repository.full_name-- provider_domains = {- ProviderType.GITHUB: 'github.com',- ProviderType.GITLAB: 'gitlab.com',- ProviderType.BITBUCKET: 'bitbucket.org',- }-- domain = provider_domains[provider]-- # If git_provider_tokens is provided, use the host from the token if available- if git_provider_tokens and provider in git_provider_tokens:- domain = git_provider_tokens[provider].host or domain-- # Try to use token if available, otherwise use public URL- if git_provider_tokens and provider in git_provider_tokens:- git_token = git_provider_tokens[provider].token- if git_token:- token_value = git_token.get_secret_value()- if provider == ProviderType.GITLAB:- remote_url = (- f'https://oauth2:{token_value}@{domain}/{repo_name}.git'- )- elif provider == ProviderType.BITBUCKET:- # For Bitbucket, handle username:app_password format- if ':' in token_value:- # App token format: username:app_password- remote_url = f'https://{token_value}@{domain}/{repo_name}.git'- else:- # Access token format: use x-token-auth- remote_url = f'https://x-token-auth:{token_value}@{domain}/{repo_name}.git'- else:- # GitHub- remote_url = f'https://{token_value}@{domain}/{repo_name}.git'- else:- remote_url = f'https://{domain}/{repo_name}.git'- else:- remote_url = f'https://{domain}/{repo_name}.git'-- return remote_url-def _is_gitlab_repository(self, repo_name: str) -> bool:"""Check if a repository is hosted on GitLab.@@ -760,10 +697,9 @@ fi# Get authenticated URL and do a shallow clone (--depth 1) for efficiencytry:remote_url = call_async_from_sync(- self._get_authenticated_git_url,+ self.provider_handler.get_authenticated_git_url,GENERAL_TIMEOUT,org_openhands_repo,- self.git_provider_tokens,)except Exception as e:self.log(diff --git a/openhands/server/routes/git.py b/openhands/server/routes/git.pyindex beee38185a..0d483414f6 100644--- a/openhands/server/routes/git.py+++ b/openhands/server/routes/git.py@@ -1,6 +1,15 @@+import os+import shutil+import subprocess+import tempfile+from datetime import datetime+from pathlib import Path+from types import MappingProxyType+from typing import cast+from fastapi import APIRouter, Depends, statusfrom fastapi.responses import JSONResponse-from pydantic import SecretStr+from pydantic import BaseModel, SecretStrfrom openhands.core.logger import openhands_logger as loggerfrom openhands.integrations.provider import (@@ -10,11 +19,14 @@ from openhands.integrations.provider import (from openhands.integrations.service_types import (AuthenticationError,Branch,+ ProviderType,Repository,SuggestedTask,UnknownException,User,)+from openhands.microagent import load_microagents_from_dir+from openhands.microagent.types import InputMetadatafrom openhands.server.dependencies import get_dependenciesfrom openhands.server.shared import server_configfrom openhands.server.user_auth import (@@ -229,3 +241,326 @@ async def get_repository_branches(content='Git provider token required. (such as GitHub).',status_code=status.HTTP_401_UNAUTHORIZED,)+++class MicroagentResponse(BaseModel):+ """Response model for microagents endpoint."""++ name: str+ type: str+ content: str+ triggers: list[str] = []+ inputs: list[InputMetadata] = []+ tools: list[str] = []+ created_at: datetime+ git_provider: ProviderType+++def _get_file_creation_time(repo_dir: Path, file_path: Path) -> datetime:+ """Get the creation time of a file from Git history.++ Args:+ repo_dir: The root directory of the Git repository+ file_path: The path to the file relative to the repository root++ Returns:+ datetime: The timestamp when the file was first added to the repository+ """+ try:+ # Get the relative path from the repository root+ relative_path = file_path.relative_to(repo_dir)++ # Use git log to get the first commit that added this file+ # --follow: follow renames and moves+ # --reverse: show commits in reverse chronological order (oldest first)+ # --format=%ct: show commit timestamp in Unix format+ # -1: limit to 1 result (the first commit)+ cmd = [+ 'git',+ 'log',+ '--follow',+ '--reverse',+ '--format=%ct',+ '-1',+ str(relative_path),+ ]++ result = subprocess.run(+ cmd, cwd=repo_dir, capture_output=True, text=True, timeout=10+ )++ if result.returncode == 0 and result.stdout.strip():+ # Parse Unix timestamp and convert to datetime+ timestamp = int(result.stdout.strip())+ return datetime.fromtimestamp(timestamp)+ else:+ logger.warning(+ f'Failed to get creation time for {relative_path}: {result.stderr}'+ )+ # Fallback to current time if git log fails+ return datetime.now()++ except Exception as e:+ logger.warning(f'Error getting creation time for {file_path}: {str(e)}')+ # Fallback to current time if there's any error+ return datetime.now()+++async def _verify_repository_access(+ repository_name: str,+ provider_tokens: PROVIDER_TOKEN_TYPE | None,+ access_token: SecretStr | None,+ user_id: str | None,+) -> Repository:+ """Verify repository access and return repository information.++ Args:+ repository_name: Repository name in the format 'owner/repo'+ provider_tokens: Provider tokens for authentication+ access_token: Access token for external authentication+ user_id: User ID for authentication++ Returns:+ Repository object with provider information++ Raises:+ AuthenticationError: If authentication fails+ """+ provider_handler = ProviderHandler(+ provider_tokens=provider_tokens+ or cast(PROVIDER_TOKEN_TYPE, MappingProxyType({})),+ external_auth_token=access_token,+ external_auth_id=user_id,+ )++ repository = await provider_handler.verify_repo_provider(repository_name)+ logger.info(+ f'Detected git provider: {repository.git_provider} for repository: {repository_name}'+ )+ return repository+++def _clone_repository(remote_url: str, repository_name: str) -> Path:+ """Clone repository to temporary directory.++ Args:+ remote_url: Authenticated git URL for cloning+ repository_name: Repository name for error messages++ Returns:+ Path to the cloned repository directory++ Raises:+ RuntimeError: If cloning fails+ """+ temp_dir = tempfile.mkdtemp()+ repo_dir = Path(temp_dir) / 'repo'++ clone_cmd = ['git', 'clone', '--depth', '1', remote_url, str(repo_dir)]++ # Set environment variable to avoid interactive prompts+ env = os.environ.copy()+ env['GIT_TERMINAL_PROMPT'] = '0'++ result = subprocess.run(+ clone_cmd,+ capture_output=True,+ text=True,+ env=env,+ timeout=30, # 30 second timeout+ )++ if result.returncode != 0:+ # Clean up on failure+ shutil.rmtree(temp_dir, ignore_errors=True)+ error_msg = f'Failed to clone repository: {result.stderr}'+ logger.error(f'Failed to clone repository {repository_name}: {result.stderr}')+ raise RuntimeError(error_msg)++ return repo_dir+++def _extract_repo_name(repository_name: str) -> str:+ """Extract the actual repository name from the full repository path.++ Args:+ repository_name: Repository name in format 'owner/repo' or 'domain/owner/repo'++ Returns:+ The actual repository name (last part after the last '/')+ """+ return repository_name.split('/')[-1]+++def _process_microagents(+ repo_dir: Path,+ repository_name: str,+ git_provider: ProviderType,+) -> list[MicroagentResponse]:+ """Process microagents from the cloned repository.++ Args:+ repo_dir: Path to the cloned repository directory+ repository_name: Repository name for logging+ git_provider: Git provider type++ Returns:+ List of microagents found in the repository+ """+ # Extract the actual repository name from the full path+ actual_repo_name = _extract_repo_name(repository_name)++ # Determine the microagents directory based on git provider and repository name+ if git_provider != ProviderType.GITLAB and actual_repo_name == '.openhands':+ # For non-GitLab providers with repository name ".openhands", scan "microagents" folder+ microagents_dir = repo_dir / 'microagents'+ elif git_provider == ProviderType.GITLAB and actual_repo_name == 'openhands-config':+ # For GitLab with repository name "openhands-config", scan "microagents" folder+ microagents_dir = repo_dir / 'microagents'+ else:+ # Default behavior: look for .openhands/microagents directory+ microagents_dir = repo_dir / '.openhands' / 'microagents'++ if not microagents_dir.exists():+ logger.info(+ f'No microagents directory found in {repository_name} at {microagents_dir}'+ )+ return []++ # Load microagents from the directory+ repo_agents, knowledge_agents = load_microagents_from_dir(microagents_dir)++ # Prepare response+ microagents = []++ # Add repo microagents+ for name, r_agent in repo_agents.items():+ # Get the actual creation time from Git+ agent_file_path = Path(r_agent.source)+ created_at = _get_file_creation_time(repo_dir, agent_file_path)++ microagents.append(+ MicroagentResponse(+ name=name,+ type='repo',+ content=r_agent.content,+ triggers=[],+ inputs=r_agent.metadata.inputs,+ tools=(+ [server.name for server in r_agent.metadata.mcp_tools.stdio_servers]+ if r_agent.metadata.mcp_tools+ else []+ ),+ created_at=created_at,+ git_provider=git_provider,+ )+ )++ # Add knowledge microagents+ for name, k_agent in knowledge_agents.items():+ # Get the actual creation time from Git+ agent_file_path = Path(k_agent.source)+ created_at = _get_file_creation_time(repo_dir, agent_file_path)++ microagents.append(+ MicroagentResponse(+ name=name,+ type='knowledge',+ content=k_agent.content,+ triggers=k_agent.triggers,+ inputs=k_agent.metadata.inputs,+ tools=(+ [server.name for server in k_agent.metadata.mcp_tools.stdio_servers]+ if k_agent.metadata.mcp_tools+ else []+ ),+ created_at=created_at,+ git_provider=git_provider,+ )+ )++ logger.info(f'Found {len(microagents)} microagents in {repository_name}')+ return microagents+++ '/repository/{repository_name:path}/microagents',+ response_model=list[MicroagentResponse],+)+async def get_repository_microagents(+ repository_name: str,+ provider_tokens: PROVIDER_TOKEN_TYPE | None = Depends(get_provider_tokens),+ access_token: SecretStr | None = Depends(get_access_token),+ user_id: str | None = Depends(get_user_id),+) -> list[MicroagentResponse] | JSONResponse:+ """Scan the microagents directory of a repository and return the list of microagents.++ The microagents directory location depends on the git provider and actual repository name:+ - If git provider is not GitLab and actual repository name is ".openhands": scans "microagents" folder+ - If git provider is GitLab and actual repository name is "openhands-config": scans "microagents" folder+ - Otherwise: scans ".openhands/microagents" folder++ Args:+ repository_name: Repository name in the format 'owner/repo' or 'domain/owner/repo'+ provider_tokens: Provider tokens for authentication+ access_token: Access token for external authentication+ user_id: User ID for authentication++ Returns:+ List of microagents found in the repository's microagents directory+ """+ repo_dir = None++ try:+ # Verify repository access and get provider information+ repository = await _verify_repository_access(+ repository_name, provider_tokens, access_token, user_id+ )++ # Construct authenticated git URL using provider handler+ provider_handler = ProviderHandler(+ provider_tokens=provider_tokens+ or cast(PROVIDER_TOKEN_TYPE, MappingProxyType({})),+ external_auth_token=access_token,+ external_auth_id=user_id,+ )+ remote_url = await provider_handler.get_authenticated_git_url(repository_name)++ # Clone repository+ repo_dir = _clone_repository(remote_url, repository_name)++ # Process microagents+ microagents = _process_microagents(+ repo_dir, repository_name, repository.git_provider+ )++ return microagents++ except AuthenticationError as e:+ logger.info(+ f'Returning 401 Unauthorized - Authentication error for user_id: {user_id}, error: {str(e)}'+ )+ return JSONResponse(+ content=str(e),+ status_code=status.HTTP_401_UNAUTHORIZED,+ )++ except RuntimeError as e:+ return JSONResponse(+ content=str(e),+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,+ )++ except Exception as e:+ logger.error(+ f'Error scanning repository {repository_name}: {str(e)}', exc_info=True+ )+ return JSONResponse(+ content=f'Error scanning repository: {str(e)}',+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,+ )++ finally:+ # Clean up temporary directory+ if repo_dir and repo_dir.parent.exists():+ shutil.rmtree(repo_dir.parent, ignore_errors=True)diff --git a/tests/unit/test_get_repository_microagents.py b/tests/unit/test_get_repository_microagents.pynew file mode 100644index 0000000000..53d99c6b10--- /dev/null+++ b/tests/unit/test_get_repository_microagents.py@@ -0,0 +1,812 @@+import os+import shutil+import tempfile+from datetime import datetime+from pathlib import Path+from types import MappingProxyType+from unittest.mock import AsyncMock, MagicMock, patch++import pytest+from fastapi import FastAPI+from fastapi.testclient import TestClient+from pydantic import SecretStr++from openhands.core.config.mcp_config import MCPConfig, MCPStdioServerConfig+from openhands.integrations.provider import ProviderToken, ProviderType+from openhands.integrations.service_types import (+ AuthenticationError,+ Repository,+)+from openhands.microagent.microagent import KnowledgeMicroagent, RepoMicroagent+from openhands.microagent.types import InputMetadata, MicroagentMetadata, MicroagentType+from openhands.server.routes.git import app as git_app+from openhands.server.user_auth import (+ get_access_token,+ get_provider_tokens,+ get_user_id,+)+++def test_client():+ """Create a test client for the git API."""+ app = FastAPI()+ app.include_router(git_app)++ # Mock SESSION_API_KEY to None to disable authentication in tests+ with patch.dict(os.environ, {'SESSION_API_KEY': ''}, clear=False):+ # Clear the SESSION_API_KEY to disable auth dependency+ with patch('openhands.server.dependencies._SESSION_API_KEY', None):+ # Override the FastAPI dependencies directly+ def mock_get_provider_tokens():+ return MappingProxyType(+ {+ ProviderType.GITHUB: ProviderToken(+ token=SecretStr('ghp_test_token'), host='github.com'+ )+ }+ )++ def mock_get_access_token():+ return None++ def mock_get_user_id():+ return 'test_user'++ # Override the dependencies in the app+ app.dependency_overrides[get_provider_tokens] = mock_get_provider_tokens+ app.dependency_overrides[get_access_token] = mock_get_access_token+ app.dependency_overrides[get_user_id] = mock_get_user_id++ yield TestClient(app)+++def mock_provider_tokens():+ """Create mock provider tokens for testing."""+ return MappingProxyType(+ {+ ProviderType.GITHUB: ProviderToken(+ token=SecretStr('ghp_test_token'), host='github.com'+ ),+ ProviderType.GITLAB: ProviderToken(+ token=SecretStr('glpat_test_token'), host='gitlab.com'+ ),+ ProviderType.BITBUCKET: ProviderToken(+ token=SecretStr('test_token'), host='bitbucket.org'+ ),+ }+ )+++def mock_repo_microagent():+ """Create a mock repository microagent."""+ return RepoMicroagent(+ name='test_repo_agent',+ content='This is a test repository microagent for testing purposes.',+ metadata=MicroagentMetadata(+ name='test_repo_agent',+ type=MicroagentType.REPO_KNOWLEDGE,+ inputs=[+ InputMetadata(+ name='query',+ type='str',+ description='Search query for the repository',+ )+ ],+ mcp_tools=MCPConfig(+ stdio_servers=[+ MCPStdioServerConfig(name='git', command='git'),+ MCPStdioServerConfig(name='file_editor', command='editor'),+ ]+ ),+ ),+ source='test_source',+ type=MicroagentType.REPO_KNOWLEDGE,+ )+++def mock_knowledge_microagent():+ """Create a mock knowledge microagent."""+ return KnowledgeMicroagent(+ name='test_knowledge_agent',+ content='This is a test knowledge microagent for testing purposes.',+ metadata=MicroagentMetadata(+ name='test_knowledge_agent',+ type=MicroagentType.KNOWLEDGE,+ inputs=[+ InputMetadata(+ name='topic', type='str', description='Topic to search for'+ )+ ],+ mcp_tools=MCPConfig(+ stdio_servers=[+ MCPStdioServerConfig(name='search', command='search'),+ MCPStdioServerConfig(name='fetch', command='fetch'),+ ]+ ),+ ),+ source='test_source',+ type=MicroagentType.KNOWLEDGE,+ triggers=['test', 'knowledge', 'search'],+ )+++def temp_microagents_dir():+ """Create a temporary directory with microagents for testing."""+ temp_dir = tempfile.mkdtemp()+ microagents_dir = Path(temp_dir) / 'repo' / '.openhands' / 'microagents'+ microagents_dir.mkdir(parents=True, exist_ok=True)++ # Create sample microagent files+ repo_agent_file = microagents_dir / 'test_repo_agent.md'+ repo_agent_file.write_text(+ """---+name: test_repo_agent+type: repo_knowledge+inputs:+ - name: query+ type: str+ description: Search query for the repository+mcp_tools:+ stdio_servers:+ - name: git+ command: git+ - name: file_editor+ command: editor+---++This is a test repository microagent for testing purposes.+"""+ )++ knowledge_agent_file = microagents_dir / 'test_knowledge_agent.md'+ knowledge_agent_file.write_text(+ """---+name: test_knowledge_agent+type: knowledge+triggers: [test, knowledge, search]+inputs:+ - name: topic+ type: str+ description: Topic to search for+mcp_tools:+ stdio_servers:+ - name: search+ command: search+ - name: fetch+ command: fetch+---++This is a test knowledge microagent for testing purposes.+"""+ )++ yield temp_dir+ shutil.rmtree(temp_dir, ignore_errors=True)+++def mock_repository():+ """Create a mock repository for testing."""+ return Repository(+ id='123456',+ full_name='test/repo',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ stargazers_count=100,+ )+++def mock_provider_handler(mock_repository):+ """Create a mock provider handler for testing."""+ handler = MagicMock()+ handler.verify_repo_provider = AsyncMock(return_value=mock_repository)+ handler.get_authenticated_git_url = AsyncMock(+ return_value='https://[email protected]/test/repo.git'+ )+ return handler+++def mock_subprocess_result():+ """Create a mock subprocess result for testing."""+ result = MagicMock()+ result.returncode = 0+ result.stderr = ''+ return result+++def mock_microagents_data(mock_repo_microagent, mock_knowledge_microagent):+ """Create mock microagents data for testing."""+ return (+ {'test_repo_agent': mock_repo_microagent},+ {'test_knowledge_agent': mock_knowledge_microagent},+ )+++class TestGetRepositoryMicroagents:+ """Test cases for the get_repository_microagents API endpoint."""++ @pytest.mark.asyncio+ @patch(+ 'openhands.server.routes.git._get_file_creation_time',+ return_value=datetime.now(),+ )+ @patch('openhands.server.routes.git.tempfile.mkdtemp')+ @patch('openhands.server.routes.git.load_microagents_from_dir')+ @patch('openhands.server.routes.git.subprocess.run')+ @patch('openhands.server.routes.git.ProviderHandler')+ async def test_get_microagents_success(+ self,+ mock_provider_handler_class,+ mock_subprocess_run,+ mock_load_microagents,+ mock_mkdtemp,+ mock_get_file_creation_time,+ test_client,+ mock_provider_tokens,+ mock_repo_microagent,+ mock_knowledge_microagent,+ temp_microagents_dir,+ mock_microagents_data,+ ):+ """Test successful retrieval of microagents from a repository."""+ # Setup mocks+ test_client.app.dependency_overrides[get_provider_tokens] = (+ lambda: mock_provider_tokens+ )++ mock_provider_handler = MagicMock()+ mock_repository = Repository(+ id='123456',+ full_name='test/repo',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ stargazers_count=100,+ )+ mock_provider_handler.verify_repo_provider = AsyncMock(+ return_value=mock_repository+ )+ mock_provider_handler.get_authenticated_git_url = AsyncMock(+ return_value='https://[email protected]/test/repo.git'+ )+ mock_provider_handler_class.return_value = mock_provider_handler++ mock_result = MagicMock()+ mock_result.returncode = 0+ mock_result.stderr = ''+ mock_subprocess_run.return_value = mock_result++ mock_load_microagents.return_value = mock_microagents_data+ mock_mkdtemp.return_value = temp_microagents_dir++ # Execute test+ response = test_client.get('/api/user/repository/test/repo/microagents')++ # Assertions+ assert response.status_code == 200+ data = response.json()+ assert len(data) == 2++ # Check repo microagent+ repo_agent = next(m for m in data if m['name'] == 'test_repo_agent')+ assert repo_agent['type'] == 'repo'+ assert (+ repo_agent['content']+ == 'This is a test repository microagent for testing purposes.'+ )+ assert repo_agent['triggers'] == []+ assert len(repo_agent['inputs']) == 1+ assert repo_agent['inputs'][0]['name'] == 'query'+ assert repo_agent['tools'] == ['git', 'file_editor']+ assert 'created_at' in repo_agent+ assert 'git_provider' in repo_agent+ assert repo_agent['git_provider'] == 'github'++ # Check knowledge microagent+ knowledge_agent = next(m for m in data if m['name'] == 'test_knowledge_agent')+ assert knowledge_agent['type'] == 'knowledge'+ assert (+ knowledge_agent['content']+ == 'This is a test knowledge microagent for testing purposes.'+ )+ assert knowledge_agent['triggers'] == mock_knowledge_microagent.triggers+ assert len(knowledge_agent['inputs']) == 1+ assert knowledge_agent['inputs'][0]['name'] == 'topic'+ assert knowledge_agent['tools'] == ['search', 'fetch']+ assert 'created_at' in knowledge_agent+ assert 'git_provider' in knowledge_agent+ assert knowledge_agent['git_provider'] == 'github'++ @pytest.mark.asyncio+ @patch('openhands.server.routes.git.ProviderHandler')+ async def test_get_microagents_authentication_error(+ self, mock_provider_handler_class, test_client, mock_provider_tokens+ ):+ """Test authentication error when verifying repository."""+ # Setup mocks+ test_client.app.dependency_overrides[get_provider_tokens] = (+ lambda: mock_provider_tokens+ )++ mock_provider_handler = MagicMock()+ mock_provider_handler.verify_repo_provider = AsyncMock(+ side_effect=AuthenticationError('Invalid credentials')+ )+ mock_provider_handler_class.return_value = mock_provider_handler++ # Execute test+ response = test_client.get('/api/user/repository/test/repo/microagents')++ # Assertions+ assert response.status_code == 401+ assert response.json() == 'Invalid credentials'++ @pytest.mark.asyncio+ @patch('openhands.server.routes.git.subprocess.run')+ @patch('openhands.server.routes.git.ProviderHandler')+ async def test_get_microagents_clone_failure(+ self,+ mock_provider_handler_class,+ mock_subprocess_run,+ test_client,+ mock_provider_tokens,+ ):+ """Test error when git clone fails."""+ # Setup mocks+ test_client.app.dependency_overrides[get_provider_tokens] = (+ lambda: mock_provider_tokens+ )++ mock_provider_handler = MagicMock()+ mock_repository = Repository(+ id='123456',+ full_name='test/repo',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ stargazers_count=100,+ )+ mock_provider_handler.verify_repo_provider = AsyncMock(+ return_value=mock_repository+ )+ mock_provider_handler.get_authenticated_git_url = AsyncMock(+ return_value='https://[email protected]/test/repo.git'+ )+ mock_provider_handler_class.return_value = mock_provider_handler++ # Mock subprocess.run to fail+ mock_result = MagicMock()+ mock_result.returncode = 1+ mock_result.stderr = 'Repository not found'+ mock_subprocess_run.return_value = mock_result++ # Execute test+ response = test_client.get('/api/user/repository/test/repo/microagents')++ # Assertions+ assert response.status_code == 500+ assert 'Failed to clone repository' in response.json()++ @pytest.mark.asyncio+ @patch('openhands.server.routes.git.tempfile.mkdtemp')+ @patch('openhands.server.routes.git.subprocess.run')+ @patch('openhands.server.routes.git.ProviderHandler')+ async def test_get_microagents_no_microagents_directory(+ self,+ mock_provider_handler_class,+ mock_subprocess_run,+ mock_mkdtemp,+ test_client,+ mock_provider_tokens,+ ):+ """Test when repository has no .openhands/microagents directory."""+ # Setup mocks+ test_client.app.dependency_overrides[get_provider_tokens] = (+ lambda: mock_provider_tokens+ )++ mock_provider_handler = MagicMock()+ mock_repository = Repository(+ id='123456',+ full_name='test/repo',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ stargazers_count=100,+ )+ mock_provider_handler.verify_repo_provider = AsyncMock(+ return_value=mock_repository+ )+ mock_provider_handler.get_authenticated_git_url = AsyncMock(+ return_value='https://[email protected]/test/repo.git'+ )+ mock_provider_handler_class.return_value = mock_provider_handler++ # Mock subprocess.run for successful clone+ mock_result = MagicMock()+ mock_result.returncode = 0+ mock_result.stderr = ''+ mock_subprocess_run.return_value = mock_result++ # Mock tempfile.mkdtemp to return a path that doesn't have microagents+ temp_dir = '/tmp/test_no_microagents'+ mock_mkdtemp.return_value = temp_dir++ # Execute test+ response = test_client.get('/api/user/repository/test/repo/microagents')++ # Assertions+ assert response.status_code == 200+ data = response.json()+ assert data == []++ @pytest.mark.asyncio+ @patch('openhands.server.routes.git.load_microagents_from_dir')+ @patch('openhands.server.routes.git.subprocess.run')+ @patch('openhands.server.routes.git.ProviderHandler')+ async def test_get_microagents_empty_directory(+ self,+ mock_provider_handler_class,+ mock_subprocess_run,+ mock_load_microagents,+ test_client,+ mock_provider_tokens,+ ):+ """Test when microagents directory exists but is empty."""+ # Setup mocks+ test_client.app.dependency_overrides[get_provider_tokens] = (+ lambda: mock_provider_tokens+ )++ mock_provider_handler = MagicMock()+ mock_repository = Repository(+ id='123456',+ full_name='test/repo',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ stargazers_count=100,+ )+ mock_provider_handler.verify_repo_provider = AsyncMock(+ return_value=mock_repository+ )+ mock_provider_handler.get_authenticated_git_url = AsyncMock(+ return_value='https://[email protected]/test/repo.git'+ )+ mock_provider_handler_class.return_value = mock_provider_handler++ # Mock subprocess.run for successful clone+ mock_result = MagicMock()+ mock_result.returncode = 0+ mock_result.stderr = ''+ mock_subprocess_run.return_value = mock_result++ # Mock load_microagents_from_dir to return empty results+ mock_load_microagents.return_value = ({}, {})++ # Execute test+ response = test_client.get('/api/user/repository/test/repo/microagents')++ # Assertions+ assert response.status_code == 200+ data = response.json()+ assert data == []++ @pytest.mark.asyncio+ @patch(+ 'openhands.server.routes.git._get_file_creation_time',+ return_value=datetime.now(),+ )+ @patch('openhands.server.routes.git.tempfile.mkdtemp')+ @patch('openhands.server.routes.git.load_microagents_from_dir')+ @patch('openhands.server.routes.git.subprocess.run')+ @patch('openhands.server.routes.git.ProviderHandler')+ async def test_get_microagents_different_providers(+ self,+ mock_provider_handler_class,+ mock_subprocess_run,+ mock_load_microagents,+ mock_mkdtemp,+ mock_get_file_creation_time,+ test_client,+ mock_repo_microagent,+ ):+ """Test microagents endpoint with GitHub provider."""+ # Setup mocks+ provider_tokens = MappingProxyType(+ {+ ProviderType.GITHUB: ProviderToken(+ token=SecretStr('ghp_test_token'), host='github.com'+ )+ }+ )+ test_client.app.dependency_overrides[get_provider_tokens] = (+ lambda: provider_tokens+ )++ mock_provider_handler = MagicMock()+ mock_repository = Repository(+ id='123456',+ full_name='test/repo',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ stargazers_count=100,+ )+ mock_provider_handler.verify_repo_provider = AsyncMock(+ return_value=mock_repository+ )+ mock_provider_handler.get_authenticated_git_url = AsyncMock(+ return_value='https://[email protected]/test/repo.git'+ )+ mock_provider_handler_class.return_value = mock_provider_handler++ # Mock subprocess.run for successful clone+ mock_result = MagicMock()+ mock_result.returncode = 0+ mock_result.stderr = ''+ mock_subprocess_run.return_value = mock_result++ # Create temporary directory with microagents+ temp_dir = tempfile.mkdtemp()+ microagents_dir = Path(temp_dir) / 'repo' / '.openhands' / 'microagents'+ microagents_dir.mkdir(parents=True, exist_ok=True)++ # Mock load_microagents_from_dir+ mock_repo_agents = {'test_repo_agent': mock_repo_microagent}+ mock_knowledge_agents = {}+ mock_load_microagents.return_value = (mock_repo_agents, mock_knowledge_agents)+ mock_mkdtemp.return_value = temp_dir++ try:+ # Execute test+ response = test_client.get('/api/user/repository/test/repo/microagents')++ # Assertions+ assert response.status_code == 200+ data = response.json()+ assert len(data) == 1+ assert data[0]['name'] == 'test_repo_agent'+ assert data[0]['type'] == 'repo'+ assert 'created_at' in data[0]+ assert 'git_provider' in data[0]+ assert data[0]['git_provider'] == 'github'+ finally:+ shutil.rmtree(temp_dir, ignore_errors=True)++ @pytest.mark.asyncio+ @patch(+ 'openhands.server.routes.git._get_file_creation_time',+ return_value=datetime.now(),+ )+ @patch('openhands.server.routes.git.tempfile.mkdtemp')+ @patch('openhands.server.routes.git.load_microagents_from_dir')+ @patch('openhands.server.routes.git.subprocess.run')+ @patch('openhands.server.routes.git.ProviderHandler')+ async def test_get_microagents_with_external_auth(+ self,+ mock_provider_handler_class,+ mock_subprocess_run,+ mock_load_microagents,+ mock_mkdtemp,+ mock_get_file_creation_time,+ test_client,+ mock_provider_tokens,+ mock_repo_microagent,+ ):+ """Test microagents endpoint with external authentication."""+ # Setup mocks+ test_client.app.dependency_overrides[get_provider_tokens] = (+ lambda: mock_provider_tokens+ )+ test_client.app.dependency_overrides[get_access_token] = lambda: SecretStr(+ 'external_token'+ )+ test_client.app.dependency_overrides[get_user_id] = lambda: 'external_user'++ mock_provider_handler = MagicMock()+ mock_repository = Repository(+ id='123456',+ full_name='test/repo',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ stargazers_count=100,+ )+ mock_provider_handler.verify_repo_provider = AsyncMock(+ return_value=mock_repository+ )+ mock_provider_handler.get_authenticated_git_url = AsyncMock(+ return_value='https://[email protected]/test/repo.git'+ )+ mock_provider_handler_class.return_value = mock_provider_handler++ # Mock subprocess.run for successful clone+ mock_result = MagicMock()+ mock_result.returncode = 0+ mock_result.stderr = ''+ mock_subprocess_run.return_value = mock_result++ # Create temporary directory with microagents+ temp_dir = tempfile.mkdtemp()+ microagents_dir = Path(temp_dir) / 'repo' / '.openhands' / 'microagents'+ microagents_dir.mkdir(parents=True, exist_ok=True)++ # Mock load_microagents_from_dir+ mock_repo_agents = {'test_repo_agent': mock_repo_microagent}+ mock_knowledge_agents = {}+ mock_load_microagents.return_value = (mock_repo_agents, mock_knowledge_agents)+ mock_mkdtemp.return_value = temp_dir++ try:+ # Execute test+ response = test_client.get('/api/user/repository/test/repo/microagents')++ # Assertions+ assert response.status_code == 200+ data = response.json()+ assert len(data) == 1+ assert data[0]['name'] == 'test_repo_agent'+ assert 'created_at' in data[0]+ assert 'git_provider' in data[0]+ assert data[0]['git_provider'] == 'github'+ finally:+ shutil.rmtree(temp_dir, ignore_errors=True)++ @pytest.mark.asyncio+ @patch('openhands.server.routes.git.ProviderHandler')+ async def test_get_microagents_generic_exception(+ self, mock_provider_handler_class, test_client, mock_provider_tokens+ ):+ """Test handling of generic exceptions."""+ # Setup mocks+ test_client.app.dependency_overrides[get_provider_tokens] = (+ lambda: mock_provider_tokens+ )++ mock_provider_handler = MagicMock()+ mock_provider_handler.verify_repo_provider = AsyncMock(+ side_effect=Exception('Unexpected error')+ )+ mock_provider_handler_class.return_value = mock_provider_handler++ # Execute test+ response = test_client.get('/api/user/repository/test/repo/microagents')++ # Assertions+ assert response.status_code == 500+ assert 'Error scanning repository' in response.json()++ @pytest.mark.asyncio+ @patch('openhands.server.routes.git.subprocess.run')+ @patch('openhands.server.routes.git.ProviderHandler')+ async def test_get_microagents_timeout(+ self,+ mock_provider_handler_class,+ mock_subprocess_run,+ test_client,+ mock_provider_tokens,+ ):+ """Test timeout handling during git clone."""+ # Setup mocks+ test_client.app.dependency_overrides[get_provider_tokens] = (+ lambda: mock_provider_tokens+ )++ mock_provider_handler = MagicMock()+ mock_repository = Repository(+ id='123456',+ full_name='test/repo',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ stargazers_count=100,+ )+ mock_provider_handler.verify_repo_provider = AsyncMock(+ return_value=mock_repository+ )+ mock_provider_handler.get_authenticated_git_url = AsyncMock(+ return_value='https://[email protected]/test/repo.git'+ )+ mock_provider_handler_class.return_value = mock_provider_handler++ # Mock subprocess.run to raise timeout+ import subprocess++ mock_subprocess_run.side_effect = subprocess.TimeoutExpired('git', 30)++ # Execute test+ response = test_client.get('/api/user/repository/test/repo/microagents')++ # Assertions+ assert response.status_code == 500+ assert 'Error scanning repository' in response.json()++ @pytest.mark.asyncio+ @patch(+ 'openhands.server.routes.git._get_file_creation_time',+ return_value=datetime.now(),+ )+ @patch('openhands.server.routes.git.tempfile.mkdtemp')+ @patch('openhands.server.routes.git.load_microagents_from_dir')+ @patch('openhands.server.routes.git.subprocess.run')+ @patch('openhands.server.routes.git.ProviderHandler')+ async def test_get_microagents_microagents_without_mcp_tools(+ self,+ mock_provider_handler_class,+ mock_subprocess_run,+ mock_load_microagents,+ mock_mkdtemp,+ mock_get_file_creation_time,+ test_client,+ mock_provider_tokens,+ ):+ """Test microagents without MCP tools."""+ # Setup mocks+ test_client.app.dependency_overrides[get_provider_tokens] = (+ lambda: mock_provider_tokens+ )++ # Create microagent without MCP tools+ repo_microagent = RepoMicroagent(+ name='simple_agent',+ content='Simple agent without MCP tools',+ metadata=MicroagentMetadata(+ name='simple_agent',+ type=MicroagentType.REPO_KNOWLEDGE,+ inputs=[],+ mcp_tools=None,+ ),+ source='test_source',+ type=MicroagentType.REPO_KNOWLEDGE,+ )++ mock_provider_handler = MagicMock()+ mock_repository = Repository(+ id='123456',+ full_name='test/repo',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ stargazers_count=100,+ )+ mock_provider_handler.verify_repo_provider = AsyncMock(+ return_value=mock_repository+ )+ mock_provider_handler.get_authenticated_git_url = AsyncMock(+ return_value='https://[email protected]/test/repo.git'+ )+ mock_provider_handler_class.return_value = mock_provider_handler++ # Mock subprocess.run for successful clone+ mock_result = MagicMock()+ mock_result.returncode = 0+ mock_result.stderr = ''+ mock_subprocess_run.return_value = mock_result++ # Create temporary directory with microagents+ temp_dir = tempfile.mkdtemp()+ microagents_dir = Path(temp_dir) / 'repo' / '.openhands' / 'microagents'+ microagents_dir.mkdir(parents=True, exist_ok=True)++ # Mock load_microagents_from_dir+ mock_repo_agents = {'simple_agent': repo_microagent}+ mock_knowledge_agents = {}+ mock_load_microagents.return_value = (mock_repo_agents, mock_knowledge_agents)+ mock_mkdtemp.return_value = temp_dir++ try:+ # Execute test+ response = test_client.get('/api/user/repository/test/repo/microagents')++ # Assertions+ assert response.status_code == 200+ data = response.json()+ assert len(data) == 1+ assert data[0]['name'] == 'simple_agent'+ assert data[0]['tools'] == []+ assert 'created_at' in data[0]+ assert 'git_provider' in data[0]+ assert data[0]['git_provider'] == 'github'+ finally:+ shutil.rmtree(temp_dir, ignore_errors=True)diff --git a/tests/unit/test_runtime_gitlab_microagents.py b/tests/unit/test_runtime_gitlab_microagents.pyindex 39172333c9..a363f4ed01 100644--- a/tests/unit/test_runtime_gitlab_microagents.py+++ b/tests/unit/test_runtime_gitlab_microagents.py@@ -6,6 +6,8 @@ from unittest.mock import MagicMock, patchimport pytest+from openhands.core.config import OpenHandsConfig, SandboxConfig+from openhands.events import EventStreamfrom openhands.integrations.service_types import ProviderType, Repositoryfrom openhands.microagent.microagent import (RepoMicroagent,@@ -17,8 +19,20 @@ class MockRuntime(Runtime):"""Mock runtime for testing."""def __init__(self, workspace_root: Path):+ # Create a minimal config for testing+ config = OpenHandsConfig()+ config.workspace_mount_path_in_sandbox = str(workspace_root)+ config.sandbox = SandboxConfig()++ # Create a mock event stream+ event_stream = MagicMock(spec=EventStream)++ # Initialize the parent class properly+ super().__init__(+ config=config, event_stream=event_stream, sid='test', git_provider_tokens={}+ )+self._workspace_root = workspace_root- self.git_provider_tokens = {}self._logs = []@property