fix #3845

contributing/samples/gepa/experiment.py

@@ -43,7 +43,6 @@
 from tau_bench.types import EnvRunResult
 from tau_bench.types import RunConfig
 import tau_bench_agent as tau_bench_agent_lib
-
 import utils
 
 

contributing/samples/gepa/run_experiment.py

@@ -25,7 +25,6 @@
 from absl import flags
 import experiment
 from google.genai import types
-
 import utils
 
 _OUTPUT_DIR = flags.DEFINE_string(

pyproject.toml

@@ -211,6 +211,7 @@ known_third_party = ["google.adk"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+pythonpath = "src"
 asyncio_default_fixture_loop_scope = "function"
 asyncio_mode = "auto"
 

src/google/adk/auth/auth_handler.py

@@ -7,11 +7,6 @@
 #     http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
 from __future__ import annotations
 
 from typing import TYPE_CHECKING
@@ -22,6 +17,7 @@
 from .auth_schemes import AuthSchemeType
 from .auth_schemes import OpenIdConnectWithConfig
 from .auth_tool import AuthConfig
+from .credential_manager import CredentialManager
 from .exchanger.oauth2_credential_exchanger import OAuth2CredentialExchanger
 
 if TYPE_CHECKING:
@@ -48,10 +44,14 @@ async def exchange_auth_token(
       self,
   ) -> AuthCredential:
     exchanger = OAuth2CredentialExchanger()
-    exchange_result = await exchanger.exchange(
-        self.auth_config.exchanged_auth_credential, self.auth_config.auth_scheme
-    )
-    return exchange_result.credential
+
+    credential = self.auth_config.exchanged_auth_credential
+
+    with CredentialManager.restore_client_secret(credential):
+      res = await exchanger.exchange(
+              credential, self.auth_config.auth_scheme
+      )
+    return res.credential
 
   async def parse_and_store_auth_response(self, state: State) -> None:
 
@@ -185,9 +185,15 @@ def generate_auth_uri(
       )
       scopes = list(scopes.keys())
 
+    client_id = auth_credential.oauth2.client_id
+
+    client_secret = CredentialManager.get_client_secret(client_id)
+    if not client_secret:
+      client_secret = auth_credential.oauth2.client_secret
+
     client = OAuth2Session(
-        auth_credential.oauth2.client_id,
-        auth_credential.oauth2.client_secret,
+        client_id,
+        client_secret,
         scope=" ".join(scopes),
         redirect_uri=auth_credential.oauth2.redirect_uri,
     )

src/google/adk/auth/auth_tool.py

@@ -113,7 +113,9 @@ def get_credential_key(self):
     )
 
     auth_credential = self.raw_auth_credential
-    if auth_credential and auth_credential.model_extra:
+    if auth_credential and (
+        auth_credential.model_extra or auth_credential.oauth2
+    ):
       auth_credential = auth_credential.model_copy(deep=True)
       auth_credential.model_extra.clear()
     if auth_credential and auth_credential.oauth2:

src/google/adk/auth/credential_manager.py

@@ -14,13 +14,13 @@
 
 from __future__ import annotations
 
+import contextlib
 import logging
 from typing import Optional
 
 from fastapi.openapi.models import OAuth2
 
 from ..agents.callback_context import CallbackContext
-from ..tools.openapi_tool.auth.credential_exchangers.service_account_exchanger import ServiceAccountCredentialExchanger
 from ..utils.feature_decorator import experimental
 from .auth_credential import AuthCredential
 from .auth_credential import AuthCredentialTypes
@@ -76,11 +76,23 @@ class CredentialManager:
       ```
   """
 
+  # A map to store client secrets in memory. Key is client_id, value is client_secret
+  _CLIENT_SECRETS: dict[str, str] = {}
+
   def __init__(
       self,
       auth_config: AuthConfig,
   ):
-    self._auth_config = auth_config
+    # We deep copy the auth_config to avoid modifying the original object passed
+    # by the user. This allows for safe redaction of sensitive information without
+    # causing side effects.
+
+    self._auth_config = auth_config.model_copy(deep=True)
+
+    # Secure the client secret
+    self._secure_client_secret(self._auth_config.raw_auth_credential)
+    self._secure_client_secret(self._auth_config.exchanged_auth_credential)
+
     self._exchanger_registry = CredentialExchangerRegistry()
     self._refresher_registry = CredentialRefresherRegistry()
     self._discovery_manager = OAuth2DiscoveryManager()
@@ -98,6 +110,8 @@ def __init__(
     )
 
     # TODO: Move ServiceAccountCredentialExchanger to the auth module
+    from ..tools.openapi_tool.auth.credential_exchangers.service_account_exchanger import ServiceAccountCredentialExchanger
+
     self._exchanger_registry.register(
         AuthCredentialTypes.SERVICE_ACCOUNT,
         ServiceAccountCredentialExchanger(),
@@ -111,6 +125,36 @@ def __init__(
         AuthCredentialTypes.OPEN_ID_CONNECT, oauth2_refresher
     )
 
+  def _secure_client_secret(self, credential: Optional[AuthCredential]):
+    """Extracts client secret to memory and redacts it from the credential."""
+    if (
+        credential
+        and credential.oauth2
+        and credential.oauth2.client_id
+        and credential.oauth2.client_secret
+        and credential.oauth2.client_secret != "<redacted>"
+    ):
+      logger.info(
+          f"Securing client secret for client_id: {credential.oauth2.client_id}"
+      )
+      # Store in memory map
+      CredentialManager._CLIENT_SECRETS[credential.oauth2.client_id] = (
+          credential.oauth2.client_secret
+      )
+      # Redact from config
+      credential.oauth2.client_secret = "<redacted>"
+    else:
+      if credential and credential.oauth2:
+        logger.debug(
+            f"Not securing secret for client_id {credential.oauth2.client_id}:"
+            f" secret is {credential.oauth2.client_secret}"
+        )
+
+  @staticmethod
+  def get_client_secret(client_id: str) -> Optional[str]:
+    """Retrieves the client secret for a given client_id."""
+    return CredentialManager._CLIENT_SECRETS.get(client_id)
+
   def register_credential_exchanger(
       self,
       credential_type: AuthCredentialTypes,
@@ -211,6 +255,40 @@ async def _load_from_auth_response(
     """Load credential from auth response in context."""
     return context.get_auth_response(self._auth_config)
 
+  @staticmethod
+  @contextlib.contextmanager
+  def restore_client_secret(credential: AuthCredential, secret: str = None):
+    """Context manager to temporarily restore client secret in a credential.
+
+    Args:
+        credential: The credential to restore secret for.
+        secret: Optional secret to use. If not provided, looks up by client_id.
+    """
+    if not credential or not credential.oauth2:
+      yield
+      return
+
+    restored = False
+    if secret:
+      credential.oauth2.client_secret = secret
+      restored = True
+    elif (
+        credential.oauth2.client_id
+        and credential.oauth2.client_secret == "<redacted>"
+    ):
+      stored_secret = CredentialManager.get_client_secret(
+          credential.oauth2.client_id
+      )
+      if stored_secret:
+        credential.oauth2.client_secret = stored_secret
+        restored = True
+
+    try:
+      yield
+    finally:
+      if restored:
+        credential.oauth2.client_secret = "<redacted>"
+
   async def _exchange_credential(
       self, credential: AuthCredential
   ) -> tuple[AuthCredential, bool]:
@@ -219,18 +297,21 @@ async def _exchange_credential(
     if not exchanger:
       return credential, False
 
+    from ..tools.openapi_tool.auth.credential_exchangers.service_account_exchanger import ServiceAccountCredentialExchanger
+
     if isinstance(exchanger, ServiceAccountCredentialExchanger):
       return (
           exchanger.exchange_credential(
               self._auth_config.auth_scheme, credential
           ),
           True,
       )
-
-    exchange_result = await exchanger.exchange(
-        credential, self._auth_config.auth_scheme
-    )
-    return exchange_result.credential, exchange_result.was_exchanged
+    else:
+      with self.restore_client_secret(credential):
+        exchanged_credential = await exchanger.exchange(
+            credential, self._auth_config.auth_scheme
+        )
+        return exchanged_credential.credential, True
 
   async def _refresh_credential(
       self, credential: AuthCredential

tests/unittests/agents/test_remote_a2a_agent.py

@@ -17,6 +17,7 @@
 import tempfile
 from unittest.mock import AsyncMock
 from unittest.mock import create_autospec
+from unittest.mock import MagicMock
 from unittest.mock import Mock
 from unittest.mock import patch
 
@@ -1002,7 +1003,7 @@ async def test_handle_a2a_response_with_task_submitted_and_no_update(self):
           mock_a2a_task,
           self.agent.name,
           self.mock_context,
-          self.mock_a2a_part_converter,
+          self.agent._a2a_part_converter,
       )
       # Check the parts are updated as Thought
       assert result.content.parts[0].thought is True
@@ -1770,7 +1771,7 @@ async def test_run_async_impl_successful_request(self):
           )  # Tuple with parts and context_id
 
           # Mock A2A client
-          mock_a2a_client = create_autospec(spec=A2AClient, instance=True)
+          mock_a2a_client = MagicMock(spec=A2AClient)
           mock_response = Mock()
           mock_send_message = AsyncMock()
           mock_send_message.__aiter__.return_value = [mock_response]
@@ -1909,7 +1910,7 @@ async def test_run_async_impl_with_meta_provider(self):
           )  # Tuple with parts and context_id
 
           # Mock A2A client
-          mock_a2a_client = create_autospec(spec=A2AClient, instance=True)
+          mock_a2a_client = MagicMock(spec=A2AClient)
           mock_response = Mock()
           mock_send_message = AsyncMock()
           mock_send_message.__aiter__.return_value = [mock_response]
@@ -2046,7 +2047,7 @@ async def test_run_async_impl_successful_request(self):
           )  # Tuple with parts and context_id
 
           # Mock A2A client
-          mock_a2a_client = create_autospec(spec=A2AClient, instance=True)
+          mock_a2a_client = MagicMock(spec=A2AClient)
           mock_response = Mock()
           mock_send_message = AsyncMock()
           mock_send_message.__aiter__.return_value = [mock_response]