Skip to content

πŸ™Œ 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.py
index 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):
@staticmethod
def _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 pass
credentials 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 information
conversation_id: Unique conversation identifier
@@ -1579,9 +1577,13 @@ class LiveStatusAppConversationService(AppConversationServiceBase):
acp_settings = user.agent_settings # already verified to be ACPAgentSettings
assert 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_env
provider_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 = None
if 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.py
index 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'