π OpenHands: AI-Driven Development
feat(acp): inject user secrets into ACP subprocess env (#14171)
simonrosenbergcf156b007335
diff --git a/openhands/app_server/app_conversation/live_status_app_conversation_service.py b/openhands/app_server/app_conversation/live_status_app_conversation_service.pyindex ec6f4490c3..864630005d 100644--- a/openhands/app_server/app_conversation/live_status_app_conversation_service.py+++ b/openhands/app_server/app_conversation/live_status_app_conversation_service.py@@ -1488,7 +1488,7 @@ class LiveStatusAppConversationService(AppConversationServiceBase):@staticmethoddef _acp_provider_env(user: UserInfo) -> dict[str, str]:- """Translate user credentials into ACP provider environment variables.+ """Translate UI-saved LLM credentials into provider-native env vars.The ACP subprocess reads provider credentials from environment variables.Maps the user's LLM API key to the env var expected by the active ACP@@ -1496,22 +1496,16 @@ class LiveStatusAppConversationService(AppConversationServiceBase):``None`` β users manage credentials entirely via ``acp_env``.Args:- user: User information containing credentials+ user: User information containing ACP agent settings.Returns:- Dictionary of environment variable name -> value pairs for the ACP subprocess.+ Dict of env var name β value to inject into the ACP subprocess."""- env: dict[str, str] = {}-if not isinstance(user.agent_settings, ACPAgentSettings):- return env+ return {}acp_settings = user.agent_settings-- # Pass through any explicit per-key overrides first; the API-key- # injection below will not overwrite keys already set here.- if acp_settings.acp_env:- env.update(acp_settings.acp_env)+ env: dict[str, str] = {}# Map the user's LLM API key to the env var expected by the ACP server.api_key_env = acp_settings.api_key_env_var@@ -1543,6 +1537,10 @@ class LiveStatusAppConversationService(AppConversationServiceBase):Unlike the LLM path, ACP agents run as separate subprocesses; we passcredentials via environment variables rather than injecting an LLM object.+ User secrets (Secrets panel + git provider tokens) are also passed through+ ``AgentContext.secrets`` so the SDK renders a ``<CUSTOM_SECRETS>`` block+ in the ACP prompt and injects values into the subprocess env at start time.+Args:sandbox: Sandbox informationconversation_id: Unique conversation identifier@@ -1579,9 +1577,13 @@ class LiveStatusAppConversationService(AppConversationServiceBase):acp_settings = user.agent_settings # already verified to be ACPAgentSettingsassert isinstance(acp_settings, ACPAgentSettings)- # Merge provider env vars (API keys etc.) into acp_env+ # Merge provider env vars (API keys etc.) into acp_env.+ # Priority (highest β lowest): acp_env > provider_envprovider_env = self._acp_provider_env(user)- merged_env = {**(acp_settings.acp_env or {}), **provider_env}+ merged_env: dict[str, str] = {+ **provider_env,+ **dict(acp_settings.acp_env or {}),+ }acp_agent = ACPAgent(acp_command=acp_settings.acp_command,@@ -1592,6 +1594,12 @@ class LiveStatusAppConversationService(AppConversationServiceBase):acp_prompt_timeout=acp_settings.acp_prompt_timeout,)+ # Pass user secrets via AgentContext so the SDK renders a+ # <CUSTOM_SECRETS> block in the ACP prompt and injects values into+ # the subprocess env at start time (SDK PR #2984).+ if secrets:+ acp_agent.agent_context = AgentContext(secrets=secrets)+sdk_plugins: list[PluginSource] | None = Noneif plugins:sdk_plugins = [@@ -1602,7 +1610,9 @@ class LiveStatusAppConversationService(AppConversationServiceBase):return StartACPConversationRequest(workspace=workspace,conversation_id=conversation_id,- initial_message=initial_message,+ initial_message=self._construct_initial_message_with_plugin_params(+ initial_message, plugins+ ),secrets=secrets,plugins=sdk_plugins,agent=acp_agent,diff --git a/tests/unit/app_server/test_live_status_app_conversation_service.py b/tests/unit/app_server/test_live_status_app_conversation_service.pyindex 1716094e53..7c480b8d8e 100644--- a/tests/unit/app_server/test_live_status_app_conversation_service.py+++ b/tests/unit/app_server/test_live_status_app_conversation_service.py@@ -3182,3 +3182,365 @@ class TestLoadHooksFromWorkspace:},timeout=30.0,)+++class TestAcpProviderEnv:+ """Unit tests for ``LiveStatusAppConversationService._acp_provider_env``.++ Tests the helper that translates UI-saved LLM credentials into the+ provider env vars the chosen ACP subprocess expects.+ """++ @pytest.fixture+ def _user_factory(self):+ try:+ from openhands.sdk.settings import (+ ACPAgentSettings, # type: ignore[attr-defined]+ )+ except ImportError:+ pytest.skip('ACPAgentSettings not available in this SDK build')++ def _make(+ *,+ acp_server: str = 'claude-code',+ api_key: str | None = None,+ base_url: str | None = None,+ acp_env: dict[str, str] | None = None,+ ):+ user = _TestUserInfo(+ id='user1',+ llm_model='',+ llm_base_url=None,+ llm_api_key=None,+ sandbox_grouping_strategy=SandboxGroupingStrategy.ADD_TO_ANY,+ confirmation_mode=False,+ security_analyzer=None,+ search_api_key=None,+ mcp_config=None,+ disabled_skills=[],+ )+ user.agent_settings = ACPAgentSettings(+ acp_server=acp_server, # type: ignore[arg-type]+ llm=LLM(+ model='claude-sonnet-4-5',+ api_key=SecretStr(api_key) if api_key else None,+ base_url=base_url,+ ),+ acp_env=acp_env or {},+ )+ return user++ return _make++ def test_claude_code_translates_to_anthropic_vars(self, _user_factory):+ user = _user_factory(acp_server='claude-code', api_key='sk-test-anthropic')+ env = LiveStatusAppConversationService._acp_provider_env(user)+ assert env == {'ANTHROPIC_API_KEY': 'sk-test-anthropic'}++ def test_codex_translates_to_openai_vars(self, _user_factory):+ user = _user_factory(acp_server='codex', api_key='sk-test-openai')+ env = LiveStatusAppConversationService._acp_provider_env(user)+ assert env == {'OPENAI_API_KEY': 'sk-test-openai'}++ def test_gemini_translates_to_gemini_vars(self, _user_factory):+ user = _user_factory(acp_server='gemini-cli', api_key='sk-test-gemini')+ env = LiveStatusAppConversationService._acp_provider_env(user)+ assert env == {'GEMINI_API_KEY': 'sk-test-gemini'}++ def test_custom_server_returns_empty(self, _user_factory):+ """For acp_server='custom', the user is on their own via acp_env."""+ user = _user_factory(+ acp_server='custom',+ api_key='sk-test',+ base_url='https://proxy.example.com',+ )+ env = LiveStatusAppConversationService._acp_provider_env(user)+ assert env == {}++ def test_no_credentials_returns_empty(self, _user_factory):+ """No api_key + no base_url β nothing synthesized."""+ user = _user_factory(acp_server='claude-code')+ env = LiveStatusAppConversationService._acp_provider_env(user)+ assert env == {}++ def test_no_api_key_returns_empty(self, _user_factory):+ """No api_key β nothing synthesized."""+ user = _user_factory(+ acp_server='claude-code', base_url='https://api.anthropic.com'+ )+ env = LiveStatusAppConversationService._acp_provider_env(user)+ assert env == {}+++class TestAgentKindConversationUrl:+ """Regression tests for conversation_url / live-status route dispatch.++ ``/api/conversations`` for LLM, ``/api/acp/conversations`` for ACP.+ Getting this wrong makes ACP conversations look stuck on "Loading"+ because the frontend polls the wrong route and 404s.+ """++ def test_build_conversation_url_llm(self):+ from uuid import UUID++ from openhands.app_server.app_conversation.app_conversation_models import (+ AppConversationInfo,+ )+ from openhands.app_server.sandbox.sandbox_models import (+ AGENT_SERVER,+ ExposedUrl,+ SandboxInfo,+ SandboxStatus,+ )++ # Instantiate a stripped service (no deps needed for _build_conversation).+ service = LiveStatusAppConversationService.__new__(+ LiveStatusAppConversationService+ )++ info = AppConversationInfo(+ id=UUID('11111111-1111-1111-1111-111111111111'),+ created_by_user_id=None,+ sandbox_id='sandbox-a',+ agent_kind='llm',+ )+ sandbox = SandboxInfo(+ id='sandbox-a',+ created_by_user_id=None,+ sandbox_spec_id='spec',+ status=SandboxStatus.RUNNING,+ session_api_key='sk',+ exposed_urls=[+ ExposedUrl(name=AGENT_SERVER, url='http://localhost:8000', port=8000),+ ],+ )+ result = service._build_conversation(info, sandbox, None)+ assert result is not None+ assert result.conversation_url == (+ 'http://localhost:8000/api/conversations/11111111111111111111111111111111'+ )++ def test_build_conversation_url_acp(self):+ from uuid import UUID++ from openhands.app_server.app_conversation.app_conversation_models import (+ AppConversationInfo,+ )+ from openhands.app_server.sandbox.sandbox_models import (+ AGENT_SERVER,+ ExposedUrl,+ SandboxInfo,+ SandboxStatus,+ )++ service = LiveStatusAppConversationService.__new__(+ LiveStatusAppConversationService+ )++ info = AppConversationInfo(+ id=UUID('22222222-2222-2222-2222-222222222222'),+ created_by_user_id=None,+ sandbox_id='sandbox-a',+ agent_kind='acp',+ )+ sandbox = SandboxInfo(+ id='sandbox-a',+ created_by_user_id=None,+ sandbox_spec_id='spec',+ status=SandboxStatus.RUNNING,+ session_api_key='sk',+ exposed_urls=[+ ExposedUrl(name=AGENT_SERVER, url='http://localhost:8000', port=8000),+ ],+ )+ result = service._build_conversation(info, sandbox, None)+ assert result is not None+ assert result.conversation_url == (+ 'http://localhost:8000/api/acp/conversations/'+ '22222222222222222222222222222222'+ )++ def test_agent_kind_to_router_path_known_kinds(self):+ """``'llm'`` β ``'conversations'``, ``'acp'`` β ``'acp/conversations'``."""+ from openhands.app_server.app_conversation.live_status_app_conversation_service import ( # noqa: E501+ _agent_kind_to_router_path,+ )++ assert _agent_kind_to_router_path('llm') == 'conversations'+ assert _agent_kind_to_router_path('acp') == 'acp/conversations'++ def test_agent_kind_to_router_path_unknown_falls_back(self):+ """Unknown variants fall back to the LLM route."""+ from openhands.app_server.app_conversation.live_status_app_conversation_service import ( # noqa: E501+ _agent_kind_to_router_path,+ )++ assert _agent_kind_to_router_path('future-variant') == 'conversations'+++class TestBuildAcpStartConversationRequestSecrets:+ """Tests for user-secret injection in ``_build_acp_start_conversation_request``.++ Covers issue #14167: secrets from the Secrets panel and git provider+ tokens must be available to ACP subprocesses as environment variables,+ mirroring how they flow into the regular OpenHands sandbox.+ """++ @pytest.fixture+ def service(self):+ mock_user_context = Mock(spec=UserContext)+ return LiveStatusAppConversationService(+ init_git_in_empty_workspace=True,+ user_context=mock_user_context,+ app_conversation_info_service=Mock(),+ app_conversation_start_task_service=Mock(),+ event_callback_service=Mock(),+ event_service=Mock(),+ sandbox_service=Mock(),+ sandbox_spec_service=Mock(),+ jwt_service=Mock(),+ pending_message_service=Mock(),+ sandbox_startup_timeout=30,+ sandbox_startup_poll_frequency=1,+ max_num_conversations_per_sandbox=20,+ httpx_client=Mock(),+ web_url=None,+ openhands_provider_base_url=None,+ access_token_hard_timeout=None,+ app_mode='test',+ )++ def _make_acp_user(self, acp_server='claude-code', acp_env=None, api_key=None):+ try:+ from openhands.sdk.settings import (+ ACPAgentSettings, # type: ignore[attr-defined]+ )+ except ImportError:+ pytest.skip('ACPAgentSettings not available in this SDK build')++ user = _TestUserInfo(+ id='user1',+ llm_model='',+ llm_base_url=None,+ llm_api_key=None,+ sandbox_grouping_strategy=SandboxGroupingStrategy.ADD_TO_ANY,+ confirmation_mode=False,+ security_analyzer=None,+ search_api_key=None,+ mcp_config=None,+ disabled_skills=[],+ )+ user.agent_settings = ACPAgentSettings(+ acp_server=acp_server, # type: ignore[arg-type]+ llm=LLM(+ model='claude-sonnet-4-5',+ api_key=SecretStr(api_key) if api_key else None,+ ),+ acp_env=acp_env or {},+ )+ return user++ def _call_build(self, service, user, tmp_path):+ """Wire user_context and call _build_acp_start_conversation_request."""+ service.user_context.get_user_info = AsyncMock(return_value=user)+ sandbox = Mock(spec=SandboxInfo)+ return service._build_acp_start_conversation_request(+ sandbox=sandbox,+ conversation_id=uuid4(),+ initial_message=None,+ working_dir=str(tmp_path),+ plugins=None,+ )++ @pytest.mark.asyncio+ async def test_secrets_passed_via_agent_context(self, service, tmp_path):+ """Secrets are forwarded via agent_context.secrets as SecretSource objects."""+ github_secret = StaticSecret(value=SecretStr('ghp_test123'))+ api_secret = StaticSecret(value=SecretStr('secret-value'))+ user = self._make_acp_user()+ service._setup_secrets_for_git_providers = AsyncMock(+ return_value={'GITHUB_TOKEN': github_secret, 'MY_API_KEY': api_secret}+ )++ request = await self._call_build(service, user, tmp_path)++ assert request.agent.agent_context is not None+ ctx = request.agent.agent_context.secrets+ assert ctx.get('GITHUB_TOKEN') is github_secret+ assert ctx.get('MY_API_KEY') is api_secret++ @pytest.mark.asyncio+ async def test_lookup_secret_forwarded_as_source(self, service, tmp_path):+ """LookupSecrets are forwarded as-is; the SDK resolves them at start time."""+ lookup = LookupSecret(url='https://example.com/token', headers={})+ user = self._make_acp_user()+ service._setup_secrets_for_git_providers = AsyncMock(+ return_value={'GITHUB_TOKEN': lookup}+ )++ request = await self._call_build(service, user, tmp_path)++ assert request.agent.agent_context is not None+ assert request.agent.agent_context.secrets.get('GITHUB_TOKEN') is lookup++ @pytest.mark.asyncio+ async def test_explicit_acp_env_preserved(self, service, tmp_path):+ """Explicit acp_env entries survive when secrets also present."""+ user = self._make_acp_user(acp_env={'MY_TOKEN': 'explicit-override'})+ service._setup_secrets_for_git_providers = AsyncMock(+ return_value={'OTHER': StaticSecret(value=SecretStr('other-value'))}+ )++ request = await self._call_build(service, user, tmp_path)++ assert request.agent.acp_env.get('MY_TOKEN') == 'explicit-override'++ @pytest.mark.asyncio+ async def test_provider_env_in_acp_env_secrets_in_agent_context(+ self, service, tmp_path+ ):+ """LLM credentials land in acp_env; panel secrets in agent_context."""+ user = self._make_acp_user(acp_server='claude-code', api_key='sk-ui-key')+ panel_secret = StaticSecret(value=SecretStr('sk-from-secrets-panel'))+ service._setup_secrets_for_git_providers = AsyncMock(+ return_value={'ANTHROPIC_API_KEY': panel_secret}+ )++ request = await self._call_build(service, user, tmp_path)++ assert request.agent.acp_env.get('ANTHROPIC_API_KEY') == 'sk-ui-key'+ assert request.agent.agent_context is not None+ assert (+ request.agent.agent_context.secrets.get('ANTHROPIC_API_KEY') is panel_secret+ )++ @pytest.mark.asyncio+ async def test_no_secrets_no_agent_context(self, service, tmp_path):+ """When there are no secrets, agent_context is not set."""+ user = self._make_acp_user()+ service._setup_secrets_for_git_providers = AsyncMock(return_value={})++ request = await self._call_build(service, user, tmp_path)++ assert request.agent.agent_context is None++ @pytest.mark.asyncio+ async def test_acp_env_overrides_provider_env(self, service, tmp_path):+ """Explicit acp_env entries take priority over auto-generated provider_env.++ When a user sets ANTHROPIC_API_KEY explicitly in acp_env, it must win+ over the same key that _acp_provider_env derives from the UI-saved LLM+ credentials. This exercises the merge priority:+ acp_env > provider_env > agent_context.secrets+ """+ user = self._make_acp_user(+ acp_server='claude-code',+ acp_env={'ANTHROPIC_API_KEY': 'sk-explicit-override'},+ api_key='sk-ui-key',+ )+ service._setup_secrets_for_git_providers = AsyncMock(return_value={})++ request = await self._call_build(service, user, tmp_path)++ # acp_env must win; the UI-saved key must NOT overwrite it+ assert request.agent.acp_env.get('ANTHROPIC_API_KEY') == 'sk-explicit-override'