Skip to content

πŸ™Œ 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.py
index 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 Message
from integrations.resolver_context import ResolverUserContext
+from integrations.resolver_org_router import resolve_org_for_repo
from integrations.types import ResolverViewInterface, UserData
from integrations.utils import (
ENABLE_PROACTIVE_CONVERSATION_STARTERS,
@@ -26,6 +27,7 @@ from server.auth.token_manager import TokenManager
from server.config import get_config
from storage.org_store import OrgStore
from storage.proactive_conversation_store import ProactiveConversationStore
+from storage.saas_conversation_store import SaasConversationStore
from storage.saas_secrets_store import SaasSecretsStore
from openhands.agent_server.models import SendMessageRequest
@@ -41,16 +43,14 @@ from openhands.integrations.github.github_service import GithubServiceImpl
from openhands.integrations.provider import PROVIDER_TOKEN_TYPE, ProviderType
from openhands.integrations.service_types import Comment
from openhands.sdk import TextContent
-from openhands.server.services.conversation_service import (
- initialize_conversation,
- start_conversation,
-)
+from openhands.server.services.conversation_service import start_conversation
from openhands.server.user_auth.user_auth import UserAuth
from 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_title
OH_LABEL, INLINE_OH_LABEL = get_oh_labels(HOST)
@@ -154,12 +154,17 @@ class GithubIssue(ResolverViewInterface):
return user_secrets.custom_secrets if user_secrets else None
async 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_id
return conversation_metadata
async 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.py
index 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 UserContext
from openhands.app_server.user.user_models import UserInfo
from 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_id
self._provider_handler: ProviderHandler | None = None
async def get_user_id(self) -> str | None:
diff --git a/enterprise/integrations/resolver_org_router.py b/enterprise/integrations/resolver_org_router.py
new file mode 100644
index 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 None
diff --git a/enterprise/server/utils/saas_app_conversation_info_injector.py b/enterprise/server/utils/saas_app_conversation_info_injector.py
index 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 exists
saas_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.py
index 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: sessionmaker
org_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_id
self.org_id = org_id
self.session_maker = session_maker
+ self.resolver_org_id = resolver_org_id
def _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:
# Validate
expected_user_id = UUID(self.user_id)
- expected_org_id = self.org_id
+ expected_org_id = org_id
if 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 None
return 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.py
index 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 = None
fake_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 = None
fake_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 = None
fake_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.py
index 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.py
new file mode 100644
index 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.py
index 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 None
assert 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_ID
diff --git a/enterprise/tests/unit/test_github_view.py b/enterprise/tests/unit/test_github_view.py
index 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 UUID
import pytest
from 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 None
diff --git a/enterprise/tests/unit/test_saas_conversation_store.py b/enterprise/tests/unit/test_saas_conversation_store.py
index 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:
# Assert
assert store.user_id == user_id
assert 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