π OpenHands: AI-Driven Development
feat(backend): route resolver conversations to claimed org workspaces (#13713)
Hiep Le6ad27b77bb6a
diff --git a/enterprise/integrations/github/github_view.py b/enterprise/integrations/github/github_view.pyindex 91d125b30d..cf1a68378c 100644--- a/enterprise/integrations/github/github_view.py+++ b/enterprise/integrations/github/github_view.py@@ -10,6 +10,7 @@ from integrations.github.github_types import ()from integrations.models import Messagefrom integrations.resolver_context import ResolverUserContext+from integrations.resolver_org_router import resolve_org_for_repofrom integrations.types import ResolverViewInterface, UserDatafrom integrations.utils import (ENABLE_PROACTIVE_CONVERSATION_STARTERS,@@ -26,6 +27,7 @@ from server.auth.token_manager import TokenManagerfrom server.config import get_configfrom storage.org_store import OrgStorefrom storage.proactive_conversation_store import ProactiveConversationStore+from storage.saas_conversation_store import SaasConversationStorefrom storage.saas_secrets_store import SaasSecretsStorefrom openhands.agent_server.models import SendMessageRequest@@ -41,16 +43,14 @@ from openhands.integrations.github.github_service import GithubServiceImplfrom openhands.integrations.provider import PROVIDER_TOKEN_TYPE, ProviderTypefrom openhands.integrations.service_types import Commentfrom openhands.sdk import TextContent-from openhands.server.services.conversation_service import (- initialize_conversation,- start_conversation,-)+from openhands.server.services.conversation_service import start_conversationfrom openhands.server.user_auth.user_auth import UserAuthfrom openhands.storage.data_models.conversation_metadata import (ConversationMetadata,ConversationTrigger,)from openhands.utils.async_utils import call_sync_from_async+from openhands.utils.conversation_summary import get_default_conversation_titleOH_LABEL, INLINE_OH_LABEL = get_oh_labels(HOST)@@ -154,12 +154,17 @@ class GithubIssue(ResolverViewInterface):return user_secrets.custom_secrets if user_secrets else Noneasync def initialize_new_conversation(self) -> ConversationMetadata:- # FIXME: Handle if initialize_conversation returns None-self.v1_enabled = await is_v1_enabled_for_github_resolver(self.user_info.keycloak_user_id)+ # Resolve target org based on claimed git organizations+ self.resolved_org_id = await resolve_org_for_repo(+ provider='github',+ full_repo_name=self.full_repo_name,+ keycloak_user_id=self.user_info.keycloak_user_id,+ )+logger.info(f'[GitHub V1]: User flag found for {self.user_info.keycloak_user_id} is {self.v1_enabled}')@@ -173,16 +178,28 @@ class GithubIssue(ResolverViewInterface):selected_repository=self.full_repo_name,)- conversation_metadata: ConversationMetadata = await initialize_conversation( # type: ignore[assignment]+ # Create the conversation store with resolver org routing+ # (bypasses initialize_conversation to avoid threading enterprise-only+ # resolver_org_id through the generic OSS interface)+ store = await SaasConversationStore.get_resolver_instance(+ get_config(),+ self.user_info.keycloak_user_id,+ self.resolved_org_id,+ )++ conversation_id = uuid4().hex+ conversation_metadata = ConversationMetadata(+ trigger=ConversationTrigger.RESOLVER,+ conversation_id=conversation_id,+ title=get_default_conversation_title(conversation_id),user_id=self.user_info.keycloak_user_id,- conversation_id=None,selected_repository=self.full_repo_name,selected_branch=self._get_branch_name(),- conversation_trigger=ConversationTrigger.RESOLVER,git_provider=ProviderType.GITHUB,)+ await store.save_metadata(conversation_metadata)- self.conversation_id = conversation_metadata.conversation_id+ self.conversation_id = conversation_idreturn conversation_metadataasync def create_new_conversation(@@ -294,7 +311,10 @@ class GithubIssue(ResolverViewInterface):)# Set up the GitHub user context for the V1 system- github_user_context = ResolverUserContext(saas_user_auth=saas_user_auth)+ github_user_context = ResolverUserContext(+ saas_user_auth=saas_user_auth,+ resolver_org_id=self.resolved_org_id,+ )setattr(injector_state, USER_CONTEXT_ATTR, github_user_context)async with get_app_conversation_service(diff --git a/enterprise/integrations/resolver_context.py b/enterprise/integrations/resolver_context.pyindex 30e558a111..29192d1554 100644--- a/enterprise/integrations/resolver_context.py+++ b/enterprise/integrations/resolver_context.py@@ -1,3 +1,5 @@+from uuid import UUID+from openhands.app_server.user.user_context import UserContextfrom openhands.app_server.user.user_models import UserInfofrom openhands.integrations.provider import PROVIDER_TOKEN_TYPE, ProviderHandler@@ -12,8 +14,10 @@ class ResolverUserContext(UserContext):def __init__(self,saas_user_auth: UserAuth,+ resolver_org_id: UUID | None = None,):self.saas_user_auth = saas_user_auth+ self.resolver_org_id = resolver_org_idself._provider_handler: ProviderHandler | None = Noneasync def get_user_id(self) -> str | None:diff --git a/enterprise/integrations/resolver_org_router.py b/enterprise/integrations/resolver_org_router.pynew file mode 100644index 0000000000..a06eeaae32--- /dev/null+++ b/enterprise/integrations/resolver_org_router.py@@ -0,0 +1,68 @@+"""Resolve which OpenHands organization workspace a resolver conversation should be created in.++This module provides a reusable utility for routing resolver conversations+(GitHub, GitLab, Bitbucket, Slack, etc.) to the correct OpenHands organization+workspace based on claimed Git organizations.+"""++from uuid import UUID++from storage.org_git_claim_store import OrgGitClaimStore+from storage.org_member_store import OrgMemberStore++from openhands.core.logger import openhands_logger as logger+++async def resolve_org_for_repo(+ provider: str,+ full_repo_name: str,+ keycloak_user_id: str,+) -> UUID | None:+ """Determine the OpenHands org_id for a resolver conversation.++ If the repo's git organization is claimed by an OpenHands org AND the user+ is a member of that org, returns the claiming org's ID. Otherwise returns+ None (caller should fall back to user.current_org_id / personal workspace).++ Args:+ provider: Git provider name ("github", "gitlab", "bitbucket")+ full_repo_name: Full repository name (e.g., "OpenHands/foo")+ keycloak_user_id: The user's Keycloak UUID string++ Returns:+ The org_id if the repo's org is claimed and user is a member, else None+ """+ git_org = full_repo_name.split('/')[0].lower()++ try:+ claim = await OrgGitClaimStore.get_claim_by_provider_and_git_org(+ provider, git_org+ )+ if not claim:+ logger.debug(+ f'[OrgResolver] No claim found for {provider}/{git_org}',+ )+ return None++ member = await OrgMemberStore.get_org_member(+ claim.org_id, UUID(keycloak_user_id)+ )+ if not member:+ logger.debug(+ f'[OrgResolver] User {keycloak_user_id} is not a member of org '+ f'{claim.org_id} (claimed {provider}/{git_org}). '+ f'Falling back to personal workspace.',+ )+ return None++ logger.info(+ f'[OrgResolver] Routing conversation to org {claim.org_id} '+ f'for {provider}/{git_org} (user {keycloak_user_id})',+ )+ return claim.org_id+ except Exception as e:+ logger.error(+ f'[OrgResolver] Error resolving org for {provider}/{git_org}: {e}',+ exc_info=True,+ )+ return Nonediff --git a/enterprise/server/utils/saas_app_conversation_info_injector.py b/enterprise/server/utils/saas_app_conversation_info_injector.pyindex a9432c76b3..05aaf22449 100644--- a/enterprise/server/utils/saas_app_conversation_info_injector.py+++ b/enterprise/server/utils/saas_app_conversation_info_injector.py@@ -363,6 +363,11 @@ class SaasSQLAppConversationInfoService(SQLAppConversationInfoService):if api_key_org_id is not None:org_id = api_key_org_id+ # Override with resolver org_id if set (from git org claim resolution)+ resolver_org_id = getattr(self.user_context, 'resolver_org_id', None)+ if resolver_org_id is not None:+ org_id = resolver_org_id+# Check if SAAS metadata already existssaas_query = select(StoredConversationMetadataSaas).where(StoredConversationMetadataSaas.conversation_id == str(info.id)diff --git a/enterprise/storage/saas_conversation_store.py b/enterprise/storage/saas_conversation_store.pyindex 1c9580969e..fb76b0f571 100644--- a/enterprise/storage/saas_conversation_store.py+++ b/enterprise/storage/saas_conversation_store.py@@ -34,10 +34,17 @@ class SaasConversationStore(ConversationStore):session_maker: sessionmakerorg_id: UUID | None = None # will be fetched automatically- def __init__(self, user_id: str, org_id: UUID, session_maker: sessionmaker):+ def __init__(+ self,+ user_id: str,+ org_id: UUID,+ session_maker: sessionmaker,+ resolver_org_id: UUID | None = None,+ ):self.user_id = user_idself.org_id = org_idself.session_maker = session_maker+ self.resolver_org_id = resolver_org_iddef _select_by_id(self, session, conversation_id: str):# Join StoredConversationMetadata with ConversationMetadataSaas to filter by user/org@@ -103,6 +110,13 @@ class SaasConversationStore(ConversationStore):stored_metadata = StoredConversationMetadata(**kwargs)+ # Override with resolver org_id if set (from git org claim resolution),+ # same pattern as V1's save_app_conversation_info in+ # saas_app_conversation_info_injector.py+ org_id = self.org_id+ if self.resolver_org_id is not None:+ org_id = self.resolver_org_id+def _save_metadata():with self.session_maker() as session:# Save the main conversation metadata@@ -122,13 +136,13 @@ class SaasConversationStore(ConversationStore):saas_metadata = StoredConversationMetadataSaas(conversation_id=stored_metadata.conversation_id,user_id=UUID(self.user_id),- org_id=self.org_id,+ org_id=org_id,)session.add(saas_metadata)else:# Validateexpected_user_id = UUID(self.user_id)- expected_org_id = self.org_id+ expected_org_id = org_idif saas_metadata.user_id != expected_user_id:raise ValueError(@@ -240,3 +254,19 @@ class SaasConversationStore(ConversationStore):user = await UserStore.get_user_by_id(user_id)org_id = user.current_org_id if user else Nonereturn SaasConversationStore(user_id, org_id, session_maker)++ @classmethod+ async def get_resolver_instance(+ cls,+ config: OpenHandsConfig,+ user_id: str,+ resolver_org_id: UUID | None = None,+ ) -> 'SaasConversationStore':+ """Get a store for resolver conversations with explicit org routing.++ Unlike get_instance, this accepts a resolver_org_id that overrides+ the user's default org when saving conversation metadata.+ """+ user = await UserStore.get_user_by_id(user_id)+ org_id = user.current_org_id if user else None+ return SaasConversationStore(user_id, org_id, session_maker, resolver_org_id)diff --git a/enterprise/tests/unit/integrations/github/test_github_view_v1_initial_user_message.py b/enterprise/tests/unit/integrations/github/test_github_view_v1_initial_user_message.pyindex 64a9f64388..0ad22da82e 100644--- a/enterprise/tests/unit/integrations/github/test_github_view_v1_initial_user_message.py+++ b/enterprise/tests/unit/integrations/github/test_github_view_v1_initial_user_message.py@@ -88,6 +88,7 @@ class TestGithubViewV1InitialUserMessage:view.previous_comments = [MagicMock(author='alice', body='old comment 1')]view._load_resolver_context = AsyncMock(side_effect=_load_context) # type: ignore[method-assign]+ view.resolved_org_id = Nonefake_service = _FakeAppConversationService()mock_get_app_conversation_service.return_value = (@@ -144,6 +145,7 @@ class TestGithubViewV1InitialUserMessage:]view._load_resolver_context = AsyncMock(side_effect=_load_context) # type: ignore[method-assign]+ view.resolved_org_id = Nonefake_service = _FakeAppConversationService()mock_get_app_conversation_service.return_value = (@@ -200,6 +202,7 @@ class TestGithubViewV1InitialUserMessage:view.previous_comments = []view._load_resolver_context = AsyncMock(side_effect=_load_context) # type: ignore[method-assign]+ view.resolved_org_id = Nonefake_service = _FakeAppConversationService()mock_get_service.return_value = _fake_app_conversation_service_ctx(fake_service)diff --git a/enterprise/tests/unit/integrations/test_resolver_context.py b/enterprise/tests/unit/integrations/test_resolver_context.pyindex 30ba799755..79f75259de 100644--- a/enterprise/tests/unit/integrations/test_resolver_context.py+++ b/enterprise/tests/unit/integrations/test_resolver_context.py@@ -32,6 +32,28 @@ def resolver_context(mock_saas_user_auth):return ResolverUserContext(saas_user_auth=mock_saas_user_auth)+# ---------------------------------------------------------------------------+# Tests for resolver_org_id - org routing for resolver conversations+# ---------------------------------------------------------------------------+++def test_resolver_org_id_defaults_to_none(mock_saas_user_auth):+ """Test that resolver_org_id defaults to None when not provided."""+ ctx = ResolverUserContext(saas_user_auth=mock_saas_user_auth)+ assert ctx.resolver_org_id is None+++def test_resolver_org_id_can_be_set_via_constructor(mock_saas_user_auth):+ """Test that resolver_org_id can be set via constructor for org routing."""+ from uuid import UUID++ org_id = UUID('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa')+ ctx = ResolverUserContext(+ saas_user_auth=mock_saas_user_auth, resolver_org_id=org_id+ )+ assert ctx.resolver_org_id == org_id++def create_custom_secret(value: str, description: str = 'Test secret') -> CustomSecret:"""Helper to create CustomSecret instances."""return CustomSecret(secret=SecretStr(value), description=description)diff --git a/enterprise/tests/unit/integrations/test_resolver_org_router.py b/enterprise/tests/unit/integrations/test_resolver_org_router.pynew file mode 100644index 0000000000..01b47572b4--- /dev/null+++ b/enterprise/tests/unit/integrations/test_resolver_org_router.py@@ -0,0 +1,111 @@+"""Tests for resolver org routing logic.++Tests the resolve_org_for_repo function which determines which OpenHands+organization workspace a resolver conversation should be created in.+"""++from unittest.mock import AsyncMock, MagicMock, patch+from uuid import UUID++import pytest++CLAIMING_ORG_ID = UUID('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa')+USER_ID = 'bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb'++# Patch at module level where the names are looked up+_CLAIM_STORE = 'enterprise.integrations.resolver_org_router.OrgGitClaimStore'+_MEMBER_STORE = 'enterprise.integrations.resolver_org_router.OrgMemberStore'++[email protected](autouse=True)+def mock_stores():+ """Mock OrgGitClaimStore and OrgMemberStore for all tests."""+ with (+ patch(_CLAIM_STORE) as mock_claim_store,+ patch(_MEMBER_STORE) as mock_member_store,+ ):+ mock_claim_store.get_claim_by_provider_and_git_org = AsyncMock(+ return_value=None+ )+ mock_member_store.get_org_member = AsyncMock(return_value=None)+ yield mock_claim_store, mock_member_store+++async def test_returns_org_id_when_claimed_and_user_is_member(mock_stores):+ """When the git org is claimed and the user is a member, return the claiming org's ID."""+ from enterprise.integrations.resolver_org_router import resolve_org_for_repo++ mock_claim_store, mock_member_store = mock_stores++ # Arrange+ claim = MagicMock()+ claim.org_id = CLAIMING_ORG_ID+ mock_claim_store.get_claim_by_provider_and_git_org.return_value = claim+ mock_member_store.get_org_member.return_value = MagicMock() # member exists++ # Act+ result = await resolve_org_for_repo('github', 'OpenHands/foo', USER_ID)++ # Assert+ assert result == CLAIMING_ORG_ID+ mock_claim_store.get_claim_by_provider_and_git_org.assert_called_once_with(+ 'github', 'openhands'+ )+ mock_member_store.get_org_member.assert_called_once_with(+ CLAIMING_ORG_ID, UUID(USER_ID)+ )+++async def test_returns_none_when_claimed_but_user_not_member(mock_stores):+ """When the git org is claimed but user is not a member, return None."""+ from enterprise.integrations.resolver_org_router import resolve_org_for_repo++ mock_claim_store, mock_member_store = mock_stores++ # Arrange+ claim = MagicMock()+ claim.org_id = CLAIMING_ORG_ID+ mock_claim_store.get_claim_by_provider_and_git_org.return_value = claim+ mock_member_store.get_org_member.return_value = None++ # Act+ result = await resolve_org_for_repo('github', 'OpenHands/foo', USER_ID)++ # Assert+ assert result is None+++async def test_returns_none_when_no_claim_exists(mock_stores):+ """When no org has claimed the git organization, return None."""+ from enterprise.integrations.resolver_org_router import resolve_org_for_repo++ mock_claim_store, _ = mock_stores+ mock_claim_store.get_claim_by_provider_and_git_org.return_value = None++ # Act+ result = await resolve_org_for_repo('github', 'UnclaimedOrg/repo', USER_ID)++ # Assert+ assert result is None+ mock_claim_store.get_claim_by_provider_and_git_org.assert_called_once_with(+ 'github', 'unclaimedorg'+ )+++async def test_extracts_git_org_lowercase_from_repo_name(mock_stores):+ """The git org is extracted from repo name and lowercased for claim lookup."""+ from enterprise.integrations.resolver_org_router import resolve_org_for_repo++ mock_claim_store, _ = mock_stores++ # Act+ await resolve_org_for_repo('github', 'MyOrg/some-repo', USER_ID)++ # Assert+ mock_claim_store.get_claim_by_provider_and_git_org.assert_called_once_with(+ 'github', 'myorg'+ )diff --git a/enterprise/tests/unit/storage/test_saas_sql_app_conversation_info_service.py b/enterprise/tests/unit/storage/test_saas_sql_app_conversation_info_service.pyindex c0c6f5d777..83a25d3cdf 100644--- a/enterprise/tests/unit/storage/test_saas_sql_app_conversation_info_service.py+++ b/enterprise/tests/unit/storage/test_saas_sql_app_conversation_info_service.py@@ -1306,3 +1306,100 @@ class TestApiKeyOrgIdHandling:conv_from_org1 = await user_service_org1.get_app_conversation_info(conv_id)assert conv_from_org1 is not Noneassert conv_from_org1.id == conv_id+++class TestResolverOrgIdRouting:+ """Test that resolver_org_id on user_context overrides the default org_id."""++ @pytest.mark.asyncio+ async def test_save_uses_resolver_org_id_when_set_on_context(+ self,+ async_session_with_users: AsyncSession,+ ):+ """When user_context has resolver_org_id, conversation is saved in that org."""+ from unittest.mock import AsyncMock++ from storage.stored_conversation_metadata_saas import (+ StoredConversationMetadataSaas,+ )++ from enterprise.integrations.resolver_context import ResolverUserContext++ # Arrange: user1 is in ORG1, but resolver routes to ORG2+ # Use spec to prevent MagicMock from auto-creating undefined attributes+ mock_context = MagicMock(spec=ResolverUserContext)+ mock_context.get_user_id = AsyncMock(return_value=str(USER1_ID))+ mock_context.resolver_org_id = ORG2_ID++ service = SaasSQLAppConversationInfoService(+ db_session=async_session_with_users,+ user_context=mock_context,+ )++ conv_id = uuid4()+ conv_info = AppConversationInfo(+ id=conv_id,+ created_by_user_id=str(USER1_ID),+ sandbox_id='sandbox_resolver',+ title='Resolver Routed Conversation',+ )++ # Act+ await service.save_app_conversation_info(conv_info)++ # Assert: conversation is stored in ORG2, not user's default ORG1+ saas_query = select(StoredConversationMetadataSaas).where(+ StoredConversationMetadataSaas.conversation_id == str(conv_id)+ )+ result = await async_session_with_users.execute(saas_query)+ saas_metadata = result.scalar_one_or_none()++ assert saas_metadata is not None+ assert saas_metadata.org_id == ORG2_ID+ assert saas_metadata.user_id == USER1_ID++ @pytest.mark.asyncio+ async def test_save_uses_default_org_when_resolver_org_id_is_none(+ self,+ async_session_with_users: AsyncSession,+ ):+ """When resolver_org_id is None, conversation uses user's default org."""+ from unittest.mock import AsyncMock++ from storage.stored_conversation_metadata_saas import (+ StoredConversationMetadataSaas,+ )++ from enterprise.integrations.resolver_context import ResolverUserContext++ # Arrange: user1 in ORG1 with no resolver override+ # Use spec to prevent MagicMock from auto-creating undefined attributes+ mock_context = MagicMock(spec=ResolverUserContext)+ mock_context.get_user_id = AsyncMock(return_value=str(USER1_ID))+ mock_context.resolver_org_id = None++ service = SaasSQLAppConversationInfoService(+ db_session=async_session_with_users,+ user_context=mock_context,+ )++ conv_id = uuid4()+ conv_info = AppConversationInfo(+ id=conv_id,+ created_by_user_id=str(USER1_ID),+ sandbox_id='sandbox_default',+ title='Default Org Conversation',+ )++ # Act+ await service.save_app_conversation_info(conv_info)++ # Assert: conversation stored in user's default ORG1+ saas_query = select(StoredConversationMetadataSaas).where(+ StoredConversationMetadataSaas.conversation_id == str(conv_id)+ )+ result = await async_session_with_users.execute(saas_query)+ saas_metadata = result.scalar_one_or_none()++ assert saas_metadata is not None+ assert saas_metadata.org_id == ORG1_IDdiff --git a/enterprise/tests/unit/test_github_view.py b/enterprise/tests/unit/test_github_view.pyindex 020e266bd4..3dbb3d2124 100644--- a/enterprise/tests/unit/test_github_view.py+++ b/enterprise/tests/unit/test_github_view.py@@ -1,5 +1,6 @@from unittest import TestCase, mock-from unittest.mock import MagicMock, patch+from unittest.mock import AsyncMock, MagicMock, patch+from uuid import UUIDimport pytestfrom integrations.github.github_view import GithubFactory, GithubIssue, get_oh_labels@@ -215,3 +216,119 @@ class TestGithubV1ConversationRouting(TestCase):jinja_env, saas_user_auth, conversation_metadata)mock_create_v0.assert_not_called()+++class TestGithubOrgRouting(TestCase):+ """Test org routing for GitHub resolver conversations."""++ def setUp(self):+ self.user_data = UserData(+ user_id=123, username='testuser', keycloak_user_id='test-keycloak-id'+ )+ self.raw_payload = Message(+ source=SourceType.GITHUB,+ message={+ 'payload': {+ 'action': 'opened',+ 'issue': {'number': 42},+ }+ },+ )+ self.resolved_org_id = UUID('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa')++ def _create_github_issue(self):+ return GithubIssue(+ user_info=self.user_data,+ full_repo_name='ClaimedOrg/repo',+ issue_number=42,+ installation_id=456,+ conversation_id='',+ should_extract=True,+ send_summary_instruction=False,+ is_public_repo=True,+ raw_payload=self.raw_payload,+ uuid='test-uuid',+ title='',+ description='',+ previous_comments=[],+ v1_enabled=False,+ )++ @pytest.mark.asyncio+ @patch(+ 'integrations.github.github_view.SaasConversationStore.get_resolver_instance'+ )+ @patch('integrations.github.github_view.resolve_org_for_repo')+ @patch('integrations.github.github_view.get_user_v1_enabled_setting')+ async def test_v0_passes_resolver_org_id_to_get_resolver_instance(+ self, mock_v1_setting, mock_resolve_org, mock_get_resolver+ ):+ """V0 path creates store via get_resolver_instance with resolver_org_id."""+ # Arrange+ mock_v1_setting.return_value = False+ mock_resolve_org.return_value = self.resolved_org_id+ mock_store = MagicMock()+ mock_store.save_metadata = AsyncMock()+ mock_get_resolver.return_value = mock_store++ github_issue = self._create_github_issue()++ # Act+ await github_issue.initialize_new_conversation()++ # Assert+ mock_resolve_org.assert_called_once_with(+ provider='github',+ full_repo_name='ClaimedOrg/repo',+ keycloak_user_id='test-keycloak-id',+ )+ # get_resolver_instance(config, user_id, resolver_org_id)+ args, _ = mock_get_resolver.call_args+ assert args[1] == 'test-keycloak-id'+ assert args[2] == self.resolved_org_id++ @pytest.mark.asyncio+ @patch('integrations.github.github_view.get_app_conversation_service')+ @patch('integrations.github.github_view.resolve_org_for_repo')+ @patch('integrations.github.github_view.get_user_v1_enabled_setting')+ async def test_v1_passes_resolver_org_id_to_resolver_user_context(+ self, mock_v1_setting, mock_resolve_org, mock_get_service+ ):+ """V1 path passes resolved org_id to ResolverUserContext."""+ # Arrange+ mock_v1_setting.return_value = True+ mock_resolve_org.return_value = self.resolved_org_id++ github_issue = self._create_github_issue()++ # Initialize to set resolved_org_id and v1_enabled+ await github_issue.initialize_new_conversation()++ # Assert+ assert github_issue.resolved_org_id == self.resolved_org_id++ @pytest.mark.asyncio+ @patch(+ 'integrations.github.github_view.SaasConversationStore.get_resolver_instance'+ )+ @patch('integrations.github.github_view.resolve_org_for_repo')+ @patch('integrations.github.github_view.get_user_v1_enabled_setting')+ async def test_no_claim_passes_none_resolver_org_id(+ self, mock_v1_setting, mock_resolve_org, mock_get_resolver+ ):+ """When no claim exists, resolver_org_id is None (falls back to personal workspace)."""+ # Arrange+ mock_v1_setting.return_value = False+ mock_resolve_org.return_value = None+ mock_store = MagicMock()+ mock_store.save_metadata = AsyncMock()+ mock_get_resolver.return_value = mock_store++ github_issue = self._create_github_issue()++ # Act+ await github_issue.initialize_new_conversation()++ # Assert+ args, _ = mock_get_resolver.call_args+ assert args[2] is Nonediff --git a/enterprise/tests/unit/test_saas_conversation_store.py b/enterprise/tests/unit/test_saas_conversation_store.pyindex 6492be3f7f..38eed9b514 100644--- a/enterprise/tests/unit/test_saas_conversation_store.py+++ b/enterprise/tests/unit/test_saas_conversation_store.py@@ -214,3 +214,125 @@ class TestGetInstance:# Assertassert store.user_id == user_idassert store.org_id is None++ @pytest.mark.asyncio+ async def test_get_resolver_instance_passes_resolver_org_id(self):+ """Verify get_resolver_instance forwards resolver_org_id to the store."""+ # Arrange+ user_id = '5594c7b6-f959-4b81-92e9-b09c206f5081'+ resolver_org_id = UUID('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa')+ mock_user = MagicMock(spec=User)+ mock_user.current_org_id = UUID(user_id)+ mock_config = MagicMock(spec=OpenHandsConfig)++ with patch(+ 'storage.saas_conversation_store.UserStore.get_user_by_id',+ AsyncMock(return_value=mock_user),+ ), patch('storage.saas_conversation_store.session_maker'):+ # Act+ store = await SaasConversationStore.get_resolver_instance(+ mock_config, user_id, resolver_org_id=resolver_org_id+ )++ # Assert+ assert store.resolver_org_id == resolver_org_id++ @pytest.mark.asyncio+ async def test_get_instance_does_not_have_resolver_org_id(self):+ """Verify get_instance does not set resolver_org_id (it's not a resolver path)."""+ # Arrange+ user_id = '5594c7b6-f959-4b81-92e9-b09c206f5081'+ mock_user = MagicMock(spec=User)+ mock_user.current_org_id = UUID(user_id)+ mock_config = MagicMock(spec=OpenHandsConfig)++ with patch(+ 'storage.saas_conversation_store.UserStore.get_user_by_id',+ AsyncMock(return_value=mock_user),+ ), patch('storage.saas_conversation_store.session_maker'):+ # Act+ store = await SaasConversationStore.get_instance(mock_config, user_id)++ # Assert+ assert store.resolver_org_id is None+++class TestResolverOrgIdRouting:+ """Tests for resolver_org_id overriding org_id in save_metadata."""++ @pytest.mark.asyncio+ async def test_save_metadata_uses_resolver_org_id_over_default(self, session_maker):+ """When resolver_org_id is set, save_metadata stores it instead of the default org_id."""+ # Arrange+ user_id = '5594c7b6-f959-4b81-92e9-b09c206f5081'+ default_org_id = UUID('5594c7b6-f959-4b81-92e9-b09c206f5081')+ resolver_org_id = UUID('aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa')+ store = SaasConversationStore(+ user_id, default_org_id, session_maker, resolver_org_id=resolver_org_id+ )+ metadata = ConversationMetadata(+ conversation_id='resolver-routed-conv',+ user_id=user_id,+ selected_repository='ClaimedOrg/repo',+ selected_branch=None,+ created_at=datetime.now(UTC),+ last_updated_at=datetime.now(UTC),+ )++ # Act+ await store.save_metadata(metadata)++ # Assert - verify the SaaS metadata record has the resolver org, not the default+ from storage.stored_conversation_metadata_saas import (+ StoredConversationMetadataSaas,+ )++ with session_maker() as session:+ saas_record = (+ session.query(StoredConversationMetadataSaas)+ .filter(+ StoredConversationMetadataSaas.conversation_id+ == 'resolver-routed-conv'+ )+ .first()+ )+ assert saas_record is not None+ assert saas_record.org_id == resolver_org_id+ assert saas_record.org_id != default_org_id++ @pytest.mark.asyncio+ async def test_save_metadata_uses_default_org_when_no_resolver_org(+ self, session_maker+ ):+ """When resolver_org_id is None, save_metadata uses the default org_id."""+ # Arrange+ user_id = '5594c7b6-f959-4b81-92e9-b09c206f5081'+ default_org_id = UUID('5594c7b6-f959-4b81-92e9-b09c206f5081')+ store = SaasConversationStore(user_id, default_org_id, session_maker)+ metadata = ConversationMetadata(+ conversation_id='default-org-conv',+ user_id=user_id,+ selected_repository='PersonalOrg/repo',+ selected_branch=None,+ created_at=datetime.now(UTC),+ last_updated_at=datetime.now(UTC),+ )++ # Act+ await store.save_metadata(metadata)++ # Assert+ from storage.stored_conversation_metadata_saas import (+ StoredConversationMetadataSaas,+ )++ with session_maker() as session:+ saas_record = (+ session.query(StoredConversationMetadataSaas)+ .filter(+ StoredConversationMetadataSaas.conversation_id == 'default-org-conv'+ )+ .first()+ )+ assert saas_record is not None+ assert saas_record.org_id == default_org_id