π OpenHands: AI-Driven Development
Add V1 git routes with pagination for installations and repositories (#13790)
Tim O'Farrell4e68f578075e
diff --git a/enterprise/server/routes/user.py b/enterprise/server/routes/user.pyindex f98f73f4b8..c88878f5d4 100644--- a/enterprise/server/routes/user.py+++ b/enterprise/server/routes/user.py@@ -45,7 +45,12 @@ saas_user_router = APIRouter(prefix='/api/user', dependencies=get_dependencies()token_manager = TokenManager()-@saas_user_router.get('/installations', response_model=list[str])+@saas_user_router.get(+ '/installations',+ response_model=list[str],+ deprecated=True,+ description='Deprecated: Use `/api/v1/git/installations` instead.',+)async def saas_get_user_installations(provider: ProviderType,provider_tokens: PROVIDER_TOKEN_TYPE | None = Depends(get_provider_tokens),@@ -115,7 +120,12 @@ async def saas_get_user_git_organizations(}-@saas_user_router.get('/repositories', response_model=list[Repository])+@saas_user_router.get(+ '/repositories',+ response_model=list[Repository],+ deprecated=True,+ description='Deprecated: Use `/api/v1/git/repositories` instead.',+)async def saas_get_user_repositories(sort: str = 'pushed',selected_provider: ProviderType | None = None,diff --git a/openhands/app_server/git/git_models.py b/openhands/app_server/git/git_models.pynew file mode 100644index 0000000000..6f35ae3bde--- /dev/null+++ b/openhands/app_server/git/git_models.py@@ -0,0 +1,29 @@+"""Git-related models for V1 API pagination responses."""++from pydantic import BaseModel++from openhands.integrations.service_types import Repository+++class InstallationPage(BaseModel):+ """Paginated response for installations.++ Attributes:+ items: List of installation IDs.+ next_page_id: ID for the next page, or None if there are no more pages.+ """++ items: list[str]+ next_page_id: str | None = None+++class RepositoryPage(BaseModel):+ """Paginated response for repositories.++ Attributes:+ items: List of repositories in the current page.+ next_page_id: ID for the next page, or None if there are no more pages.+ """++ items: list[Repository]+ next_page_id: str | None = Nonediff --git a/openhands/app_server/git/git_router.py b/openhands/app_server/git/git_router.pynew file mode 100644index 0000000000..f848b386a6--- /dev/null+++ b/openhands/app_server/git/git_router.py@@ -0,0 +1,147 @@+"""Git router for OpenHands App Server V1 API.++This module provides V1 API endpoints for Git operations (installations, repositories)+with pagination support. These endpoints are designed to replace the legacy V0 endpoints+in openhands/server/routes/git.py.+"""++from types import MappingProxyType+from typing import TYPE_CHECKING, Annotated++from fastapi import APIRouter, HTTPException, Query, status++from openhands.app_server.config import depends_user_context, get_global_config+from openhands.app_server.git.git_models import (+ InstallationPage,+ RepositoryPage,+)+from openhands.app_server.user.user_context import UserContext+from openhands.app_server.utils.dependencies import get_dependencies+from openhands.app_server.utils.paging_utils import (+ decode_page_id,+ encode_page_id,+ paginate_results,+)+from openhands.integrations.provider import ProviderHandler+from openhands.integrations.service_types import ProviderType++if TYPE_CHECKING:+ from openhands.integrations.provider import PROVIDER_TOKEN_TYPE++# We use the get_dependencies method here to signal to the OpenAPI docs that this endpoint+# is protected. The actual protection is provided by SetAuthCookieMiddleware+router = APIRouter(+ prefix='/git',+ tags=['Git'],+ dependencies=get_dependencies(),+)+user_context_dependency = depends_user_context()++[email protected]('/installations')+async def get_user_installations(+ provider: ProviderType,+ page_id: Annotated[+ str | None,+ Query(title='Optional next_page_id from the previously returned page'),+ ] = None,+ limit: Annotated[+ int,+ Query(title='The max number of results in the page', gt=0, le=100),+ ] = 100,+ user_context: UserContext = user_context_dependency,+) -> InstallationPage:+ """Get user installations (GitHub apps) or equivalent for other providers.++ Returns a paginated list of installation IDs or workspace IDs depending on the provider.+ """+ # Get provider tokens from user context+ provider_tokens = await user_context.get_provider_tokens()+ if not provider_tokens:+ raise HTTPException(+ status_code=status.HTTP_401_UNAUTHORIZED,+ detail='Git provider token required (such as GitHub).',+ )++ user_id = await user_context.get_user_id()+ # Wrap in MappingProxyType as required by ProviderHandler+ # Type ignore: we validated provider_tokens exists, but mypy can't narrow the union type+ client = ProviderHandler(+ provider_tokens=MappingProxyType(provider_tokens), # type: ignore[arg-type]+ external_auth_id=user_id,+ )++ if provider == ProviderType.GITHUB:+ installations = await client.get_github_installations()+ elif provider == ProviderType.BITBUCKET:+ installations = await client.get_bitbucket_workspaces()+ elif provider == ProviderType.BITBUCKET_DATA_CENTER:+ installations = await client.get_bitbucket_dc_projects()+ elif provider == ProviderType.AZURE_DEVOPS:+ installations = await client.get_azure_devops_organizations()+ else:+ raise HTTPException(+ status_code=status.HTTP_400_BAD_REQUEST,+ detail=f"Provider {provider} doesn't support installations",+ )++ items, next_page_id = paginate_results(installations, page_id, limit)+ return InstallationPage(items=items, next_page_id=next_page_id)++[email protected]('/repositories')+async def get_user_repositories(+ provider: ProviderType,+ sort: str = 'pushed',+ installation_id: str | None = None,+ page_id: Annotated[+ str | None,+ Query(title='Optional next_page_id from the previously returned page'),+ ] = None,+ limit: Annotated[+ int,+ Query(title='The max number of results in the page', gt=0, le=100),+ ] = 100,+ user_context: UserContext = user_context_dependency,+) -> RepositoryPage:+ """Get user repositories.++ Returns a paginated list of repositories for the authenticated user.+ """+ # Get provider tokens from user context+ provider_tokens = await user_context.get_provider_tokens()+ if not provider_tokens:+ raise HTTPException(+ status_code=status.HTTP_401_UNAUTHORIZED,+ detail='Git provider token required (such as GitHub).',+ )++ user_id = await user_context.get_user_id()+ # Cast to the expected type since we validated provider_tokens exists+ typed_provider_tokens: PROVIDER_TOKEN_TYPE = provider_tokens # type: ignore[assignment]+ client = ProviderHandler(+ provider_tokens=MappingProxyType(typed_provider_tokens),+ external_auth_id=user_id,+ )++ page = 1+ decoded_page_id = decode_page_id(page_id)+ if decoded_page_id is not None:+ page = decoded_page_id++ # Get repositories - we'll handle pagination ourselves+ items = await client.get_repositories(+ sort=sort,+ app_mode=get_global_config().app_mode,+ selected_provider=provider,+ page=page,+ per_page=limit + 1, # We'll handle pagination ourselves+ installation_id=installation_id,+ )++ next_page_id = None+ if len(items) > limit:+ items = items[:-1]+ next_page_id = encode_page_id(page + 1)++ return RepositoryPage(items=items, next_page_id=next_page_id)diff --git a/openhands/app_server/secrets/secrets_router.py b/openhands/app_server/secrets/secrets_router.pyindex 75d14fd587..0da621deb9 100644--- a/openhands/app_server/secrets/secrets_router.py+++ b/openhands/app_server/secrets/secrets_router.py@@ -88,7 +88,7 @@ async def check_provider_tokens(@router.post('/git-providers',- tags=['Git Providers'],+ tags=['Git'],)async def store_provider_tokens(provider_info: POSTProviderModel,@@ -136,7 +136,7 @@ async def store_provider_tokens(@router.delete('/git-providers',- tags=['Git Providers'],+ tags=['Git'],)async def unset_provider_tokens(secrets_store: SecretsStore = Depends(get_secrets_store),diff --git a/openhands/app_server/utils/paging_utils.py b/openhands/app_server/utils/paging_utils.pynew file mode 100644index 0000000000..2e3e4e0db8--- /dev/null+++ b/openhands/app_server/utils/paging_utils.py@@ -0,0 +1,81 @@+"""Pagination utilities for OpenHands App Server.++This module provides utilities for handling pagination in API responses.+The page_id is designed to be an opaque token - external consumers should not+infer details of the underlying pagination strategy (e.g., offset vs page number)+from the page_id contents, as this may change in the future.+"""++import base64+++def encode_page_id(value: int) -> str:+ """Encode an integer page identifier as an opaque base64 string.++ This function exists to ensure that page IDs are opaque tokens that do not+ reveal the underlying pagination strategy to API consumers. The encoding+ format may change in the future, so consumers should treat page_id as an+ opaque string and not attempt to parse or construct it themselves.++ Args:+ value: The integer value to encode.++ Returns:+ Base64-encoded string (URL-safe, without padding).+ """+ return base64.urlsafe_b64encode(str(value).encode()).decode().rstrip('=')+++def decode_page_id(page_id: str | None) -> int | None:+ """Decode an opaque page identifier back to an integer.++ This function exists to support the internal decoding of page IDs.+ External consumers should not need to call this function directly - they+ should pass the page_id string received from a previous response back to+ the API to get the next page of results.++ Note: The encoding format may change in the future, so this function+ should not be used to construct page_ids externally.++ Args:+ page_id: The base64-encoded page ID string.++ Returns:+ The decoded integer value, or None if page_id is None/empty.+ """+ if not page_id:+ return None+ try:+ # Add padding back if needed+ padded = page_id + '=' * (4 - len(page_id) % 4)+ decoded = base64.urlsafe_b64decode(padded.encode()).decode()+ return int(decoded)+ except (ValueError, Exception):+ return None+++def paginate_results(+ items: list, page_id: str | None, limit: int+) -> tuple[list, str | None]:+ """Apply pagination to a list of items.++ Args:+ items: Full list of items to paginate.+ page_id: Optional page token from previous request.+ limit: Maximum number of items per page.++ Returns:+ Tuple of (paginated_items, next_page_id).+ """+ start_offset = 0+ decoded_page_id = decode_page_id(page_id)+ if decoded_page_id is not None:+ start_offset = decoded_page_id++ end_offset = start_offset + limit+ paginated_items = items[start_offset:end_offset]+ next_page_id = None+ if end_offset < len(items):+ next_page_id = encode_page_id(end_offset)++ return paginated_items, next_page_iddiff --git a/openhands/app_server/v1_router.py b/openhands/app_server/v1_router.pyindex 8d1681173b..292b77b2e1 100644--- a/openhands/app_server/v1_router.py+++ b/openhands/app_server/v1_router.py@@ -5,6 +5,7 @@ from openhands.app_server.event import event_routerfrom openhands.app_server.event_callback import (webhook_router,)+from openhands.app_server.git.git_router import router as git_routerfrom openhands.app_server.pending_messages.pending_message_router import (router as pending_message_router,)@@ -31,3 +32,4 @@ router.include_router(user_router.router)router.include_router(skills_router.router)router.include_router(webhook_router.router)router.include_router(web_client_router.router)+router.include_router(git_router)diff --git a/openhands/server/routes/git.py b/openhands/server/routes/git.pyindex b4a4084c57..fa344b845d 100644--- a/openhands/server/routes/git.py+++ b/openhands/server/routes/git.py@@ -43,7 +43,12 @@ from openhands.server.user_auth import (app = APIRouter(prefix='/api/user', dependencies=get_dependencies())[email protected]('/installations', response_model=list[str])+ '/installations',+ response_model=list[str],+ deprecated=True,+ description='Deprecated: Use `/api/v1/git/installations` instead.',+)async def get_user_installations(provider: ProviderType,provider_tokens: PROVIDER_TOKEN_TYPE | None = Depends(get_provider_tokens),@@ -74,7 +79,12 @@ async def get_user_installations(raise AuthenticationError('Git provider token required. (such as GitHub).')[email protected]('/repositories', response_model=list[Repository])+ '/repositories',+ response_model=list[Repository],+ deprecated=True,+ description='Deprecated: Use `/api/v1/git/repositories` instead.',+)async def get_user_repositories(sort: str = 'pushed',selected_provider: Annotated[ProviderType | None, Query()] = None,diff --git a/tests/unit/app_server/test_git_router.py b/tests/unit/app_server/test_git_router.pynew file mode 100644index 0000000000..b62dbcae40--- /dev/null+++ b/tests/unit/app_server/test_git_router.py@@ -0,0 +1,438 @@+"""Unit tests for the git_router endpoints.++This module tests the git router endpoints,+focusing on pagination and error handling.+"""++from unittest.mock import AsyncMock, MagicMock, patch++import pytest+from fastapi import FastAPI, status+from fastapi.testclient import TestClient++from openhands.app_server.git.git_router import (+ get_user_installations,+ get_user_repositories,+ router,+)+from openhands.app_server.user.user_context import UserContext+from openhands.app_server.utils.dependencies import check_session_api_key+from openhands.app_server.utils.paging_utils import encode_page_id, paginate_results+from openhands.integrations.provider import ProviderToken+from openhands.integrations.service_types import ProviderType, Repository+++class TestPagination:+ """Test suite for pagination helper function."""++ def test_returns_first_page_when_no_page_id(self):+ """Test that first page is returned when no page_id is provided."""+ items = ['a', 'b', 'c', 'd', 'e']++ result, next_page_id = paginate_results(items, None, 2)++ assert result == ['a', 'b']+ # next_page_id is base64-encoded+ assert next_page_id == encode_page_id(2)++ def test_returns_second_page_when_page_id_provided(self):+ """Test that correct page is returned when page_id is provided."""+ items = ['a', 'b', 'c', 'd', 'e']+ # Use base64-encoded page_id+ encoded_page_id = encode_page_id(2)++ result, next_page_id = paginate_results(items, encoded_page_id, 2)++ assert result == ['c', 'd']+ assert next_page_id == encode_page_id(4)++ def test_returns_empty_when_page_id_exceeds_length(self):+ """Test that empty list is returned when page_id exceeds length."""+ items = ['a', 'b', 'c']+ # Use base64-encoded page_id+ encoded_page_id = encode_page_id(10)++ result, next_page_id = paginate_results(items, encoded_page_id, 2)++ assert result == []+ assert next_page_id is None++ def test_returns_none_next_page_when_last_page(self):+ """Test that next_page_id is None on last page."""+ items = ['a', 'b', 'c']+ # Use base64-encoded page_id+ encoded_page_id = encode_page_id(2)++ result, next_page_id = paginate_results(items, encoded_page_id, 2)++ assert result == ['c']+ assert next_page_id is None++ def test_respects_limit(self):+ """Test that limit is respected."""+ items = ['a', 'b', 'c', 'd', 'e']++ result, next_page_id = paginate_results(items, None, 5)++ assert result == items+ assert next_page_id is None+++def _make_mock_user_context(+ provider_tokens: dict | None = None,+ user_id: str = 'test-user-id',+):+ """Create a mock UserContext for testing."""+ context = MagicMock(spec=UserContext)+ context.get_provider_tokens = AsyncMock(return_value=provider_tokens)+ context.get_user_id = AsyncMock(return_value=user_id)+ return context+++def _make_mock_provider_handler():+ """Create a mock ProviderHandler."""+ handler = MagicMock()+ handler.get_github_installations = AsyncMock(+ return_value=['inst-1', 'inst-2', 'inst-3', 'inst-4', 'inst-5']+ )+ handler.get_bitbucket_workspaces = AsyncMock(return_value=['ws-1', 'ws-2'])+ handler.get_repositories = AsyncMock(return_value=[])+ return handler+++def test_client():+ """Create a test client with the actual git router and mocked dependencies.++ We override check_session_api_key to bypass auth checks.+ This allows us to test the actual Query parameter validation in the router.+ """+ app = FastAPI()+ app.include_router(router)++ # Override the auth dependency to always pass+ app.dependency_overrides[check_session_api_key] = lambda: None++ client = TestClient(app, raise_server_exceptions=False)+ yield client++ # Clean up+ app.dependency_overrides.clear()+++class TestInstallationsEndpoint:+ """Test suite for /installations endpoint."""++ def test_returns_401_when_no_provider_tokens(self, test_client, monkeypatch):+ """Test that 401 is returned when no provider tokens."""+ mock_context = _make_mock_user_context(provider_tokens=None)+ monkeypatch.setattr(+ 'openhands.app_server.git.git_router.depends_user_context',+ lambda: mock_context,+ )++ response = test_client.get('/git/installations', params={'provider': 'github'})++ assert response.status_code == status.HTTP_401_UNAUTHORIZED++ def test_returns_422_for_unsupported_provider(self, test_client, monkeypatch):+ """Test that 422 is returned for unsupported provider."""+ mock_context = _make_mock_user_context(provider_tokens={'github': 'token'})++ # Patch the ProviderHandler+ monkeypatch.setattr(+ 'openhands.app_server.git.git_router.depends_user_context',+ lambda: mock_context,+ )++ response = test_client.get('/git/installations', params={'provider': 'invalid'})+ assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY+++class TestRepositoriesEndpoint:+ """Test suite for /repositories endpoint."""++ def test_returns_401_when_no_provider_tokens(self, test_client, monkeypatch):+ """Test that 401 is returned when no provider tokens."""+ mock_context = _make_mock_user_context(provider_tokens=None)+ monkeypatch.setattr(+ 'openhands.app_server.git.git_router.depends_user_context',+ lambda: mock_context,+ )++ response = test_client.get('/git/repositories', params={'provider': 'github'})++ assert response.status_code == status.HTTP_401_UNAUTHORIZED+++class TestGetUserInstallations:+ """Test suite for get_user_installations function."""++ @pytest.mark.asyncio+ @patch('openhands.app_server.git.git_router.ProviderHandler')+ async def test_returns_paginated_installations(self, mock_handler_cls):+ """Test that installations are returned with pagination."""+ # Arrange+ mock_handler = _make_mock_provider_handler()+ mock_handler_cls.return_value = mock_handler++ mock_context = _make_mock_user_context(+ provider_tokens={+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')+ },+ user_id='user-123',+ )++ # Act+ result = await get_user_installations(+ provider=ProviderType.GITHUB,+ page_id=None,+ limit=2,+ user_context=mock_context,+ )++ # Assert+ assert result.items == ['inst-1', 'inst-2']+ # next_page_id is base64-encoded+ assert result.next_page_id == encode_page_id(2)++ @pytest.mark.asyncio+ @patch('openhands.app_server.git.git_router.ProviderHandler')+ async def test_returns_second_page_correctly(self, mock_handler_cls):+ """Test that second page of installations is returned correctly."""+ # Arrange+ mock_handler = _make_mock_provider_handler()+ mock_handler_cls.return_value = mock_handler++ mock_context = _make_mock_user_context(+ provider_tokens={+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')+ },+ user_id='user-123',+ )++ # Act - request second page+ result = await get_user_installations(+ provider=ProviderType.GITHUB,+ page_id=encode_page_id(2), # Second page starts at offset 2+ limit=2,+ user_context=mock_context,+ )++ # Assert+ assert result.items == ['inst-3', 'inst-4']+ assert result.next_page_id == encode_page_id(4)+++class TestGetUserRepositories:+ """Test suite for get_user_repositories function."""++ @pytest.mark.asyncio+ @patch('openhands.app_server.git.git_router.ProviderHandler')+ async def test_returns_repositories_with_correct_structure(self, mock_handler_cls):+ """Test that get_user_repositories returns correct RepositoryPage structure."""+ # Arrange+ mock_handler = MagicMock()+ mock_handler.get_repositories = AsyncMock(+ return_value=[+ Repository(+ id='1',+ full_name='user/repo1',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ ),+ Repository(+ id='2',+ full_name='user/repo2',+ git_provider=ProviderType.GITHUB,+ is_public=False,+ ),+ Repository(+ id='3',+ full_name='user/repo3',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ ),+ ]+ )+ mock_handler_cls.return_value = mock_handler++ mock_context = _make_mock_user_context(+ provider_tokens={+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')+ },+ user_id='user-123',+ )++ # Act+ result = await get_user_repositories(+ provider=ProviderType.GITHUB,+ sort='updated',+ installation_id=None,+ page_id=None,+ limit=10,+ user_context=mock_context,+ )++ # Assert+ assert len(result.items) == 3+ assert result.items[0].id == '1'+ assert result.items[1].id == '2'+ assert result.items[2].id == '3'+ assert result.next_page_id is None # No more pages++ @pytest.mark.asyncio+ @patch('openhands.app_server.git.git_router.ProviderHandler')+ async def test_pagination_works_across_pages(self, mock_handler_cls):+ """Test that pagination works correctly across multiple pages.++ Note: This endpoint uses page-based pagination (passing page number to provider),+ not offset-based pagination like installations. The provider returns limit+1 items,+ and we check if there are more to determine next_page_id.+ """+ # Arrange+ mock_handler = MagicMock()++ # We'll set up the mock to return different data based on the page parameter+ # First call (page=1): return 3 items (limit+1), meaning there's a next page+ # Second call (page=2): return 3 items, meaning there's a next page+ # Third call (page=3): return 2 items, meaning it's the last page+ def mock_get_repositories(**kwargs):+ page = kwargs.get('page', 1)+ if page == 1:+ return [+ Repository(+ id=str(i),+ full_name=f'user/repo{i}',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ )+ for i in range(1, 4) # 3 items = limit+1+ ]+ elif page == 2:+ return [+ Repository(+ id=str(i),+ full_name=f'user/repo{i}',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ )+ for i in range(4, 7) # 3 items = limit+1+ ]+ else:+ return [+ Repository(+ id=str(i),+ full_name=f'user/repo{i}',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ )+ for i in range(7, 9) # 2 items < limit+1 = last page+ ]++ mock_handler.get_repositories = AsyncMock(side_effect=mock_get_repositories)+ mock_handler_cls.return_value = mock_handler++ mock_context = _make_mock_user_context(+ provider_tokens={+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')+ },+ user_id='user-123',+ )++ # Act - First page (page=1)+ result_page1 = await get_user_repositories(+ provider=ProviderType.GITHUB,+ sort='pushed',+ installation_id=None,+ page_id=None, # This means page 1+ limit=2,+ user_context=mock_context,+ )++ # Assert - First page returns 2 items (truncated from limit+1=3), with next_page_id+ assert len(result_page1.items) == 2+ assert result_page1.items[0].id == '1'+ assert result_page1.items[1].id == '2'+ assert result_page1.next_page_id == encode_page_id(2)++ # Act - Second page (page=2)+ result_page2 = await get_user_repositories(+ provider=ProviderType.GITHUB,+ sort='pushed',+ installation_id=None,+ page_id=encode_page_id(2), # This means page 2+ limit=2,+ user_context=mock_context,+ )++ # Assert - Second page returns next 2 items+ assert len(result_page2.items) == 2+ assert result_page2.items[0].id == '4'+ assert result_page2.items[1].id == '5'+ # next_page_id = page + 1 = 2 + 1 = 3, encoded as base64 = 'Mw'+ assert result_page2.next_page_id == encode_page_id(3)++ @pytest.mark.asyncio+ @patch('openhands.app_server.git.git_router.ProviderHandler')+ async def test_passes_sort_parameter_to_provider(self, mock_handler_cls):+ """Test that sort parameter is passed through to the provider handler."""+ # Arrange+ mock_handler = MagicMock()+ mock_handler.get_repositories = AsyncMock(return_value=[])+ mock_handler_cls.return_value = mock_handler++ mock_context = _make_mock_user_context(+ provider_tokens={+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')+ },+ user_id='user-123',+ )++ # Act+ await get_user_repositories(+ provider=ProviderType.GITHUB,+ sort='stars',+ installation_id=None,+ page_id=None,+ limit=10,+ user_context=mock_context,+ )++ # Assert - verify get_repositories was called with the sort parameter+ mock_handler.get_repositories.assert_called_once()+ call_kwargs = mock_handler.get_repositories.call_args.kwargs+ assert call_kwargs.get('sort') == 'stars'++ @pytest.mark.asyncio+ @patch('openhands.app_server.git.git_router.ProviderHandler')+ async def test_passes_installation_id_to_provider(self, mock_handler_cls):+ """Test that installation_id filtering is passed through to the provider."""+ # Arrange+ mock_handler = MagicMock()+ mock_handler.get_repositories = AsyncMock(return_value=[])+ mock_handler_cls.return_value = mock_handler++ mock_context = _make_mock_user_context(+ provider_tokens={+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')+ },+ user_id='user-123',+ )++ # Act+ await get_user_repositories(+ provider=ProviderType.GITHUB,+ sort='pushed',+ installation_id='app-123',+ page_id=None,+ limit=10,+ user_context=mock_context,+ )++ # Assert - verify get_repositories was called with installation_id+ mock_handler.get_repositories.assert_called_once()+ call_kwargs = mock_handler.get_repositories.call_args.kwargs+ assert call_kwargs.get('installation_id') == 'app-123'