Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.
fix: clean up mcp encryption tests and logic (#2958)
jnjpngdb0032012623
diff --git a/letta/schemas/mcp.py b/letta/schemas/mcp.pyindex 6f273816d..e68d614ec 100644--- a/letta/schemas/mcp.py+++ b/letta/schemas/mcp.py@@ -14,6 +14,7 @@ from letta.functions.mcp_client.types import (from letta.orm.mcp_oauth import OAuthSessionStatusfrom letta.schemas.letta_base import LettaBasefrom letta.schemas.secret import Secret, SecretDict+from letta.settings import settingsclass BaseMCPServer(LettaBase):@@ -75,41 +76,24 @@ class MCPServer(BaseMCPServer):def model_dump(self, to_orm: bool = False, **kwargs):"""Override model_dump to handle encryption when saving to database."""- import os-- # Check environment variable directly to handle test patching- encryption_key = os.environ.get("LETTA_ENCRYPTION_KEY")- if not encryption_key:- from letta.settings import settings-- encryption_key = settings.encryption_key-data = super().model_dump(to_orm=to_orm, **kwargs)- if to_orm and encryption_key:- # Temporarily set the encryption key for Secret/SecretDict- from letta.settings import settings-- original_key = settings.encryption_key- settings.encryption_key = encryption_key- try:- # Encrypt token if present- if self.token is not None:- token_secret = Secret.from_plaintext(self.token)- secret_dict = token_secret.to_dict()- data["token_enc"] = secret_dict["encrypted"]- # Keep plaintext for dual-write during migration- data["token"] = secret_dict["plaintext"]-- # Encrypt custom headers if present- if self.custom_headers is not None:- headers_secret = SecretDict.from_plaintext(self.custom_headers)- secret_dict = headers_secret.to_dict()- data["custom_headers_enc"] = secret_dict["encrypted"]- # Keep plaintext for dual-write during migration- data["custom_headers"] = secret_dict["plaintext"]- finally:- settings.encryption_key = original_key+ if to_orm and settings.encryption_key:+ # Encrypt token if present+ if self.token is not None:+ token_secret = Secret.from_plaintext(self.token)+ secret_dict = token_secret.to_dict()+ data["token_enc"] = secret_dict["encrypted"]+ # Keep plaintext for dual-write during migration+ data["token"] = secret_dict["plaintext"]++ # Encrypt custom headers if present+ if self.custom_headers is not None:+ headers_secret = SecretDict.from_plaintext(self.custom_headers)+ secret_dict = headers_secret.to_dict()+ data["custom_headers_enc"] = secret_dict["encrypted"]+ # Keep plaintext for dual-write during migration+ data["custom_headers"] = secret_dict["plaintext"]return data@@ -277,49 +261,32 @@ class MCPOAuthSession(BaseMCPOAuth):def model_dump(self, to_orm: bool = False, **kwargs):"""Override model_dump to handle encryption when saving to database."""- import os-- # Check environment variable directly to handle test patching- encryption_key = os.environ.get("LETTA_ENCRYPTION_KEY")- if not encryption_key:- from letta.settings import settings-- encryption_key = settings.encryption_key-data = super().model_dump(to_orm=to_orm, **kwargs)- if to_orm and encryption_key:- # Temporarily set the encryption key for Secret- from letta.settings import settings-- original_key = settings.encryption_key- settings.encryption_key = encryption_key- try:- # Encrypt access token if present- if self.access_token is not None:- token_secret = Secret.from_plaintext(self.access_token)- secret_dict = token_secret.to_dict()- data["access_token_enc"] = secret_dict["encrypted"]- # Keep plaintext for dual-write during migration- data["access_token"] = secret_dict["plaintext"]-- # Encrypt refresh token if present- if self.refresh_token is not None:- token_secret = Secret.from_plaintext(self.refresh_token)- secret_dict = token_secret.to_dict()- data["refresh_token_enc"] = secret_dict["encrypted"]- # Keep plaintext for dual-write during migration- data["refresh_token"] = secret_dict["plaintext"]-- # Encrypt client secret if present- if self.client_secret is not None:- secret = Secret.from_plaintext(self.client_secret)- secret_dict = secret.to_dict()- data["client_secret_enc"] = secret_dict["encrypted"]- # Keep plaintext for dual-write during migration- data["client_secret"] = secret_dict["plaintext"]- finally:- settings.encryption_key = original_key+ if to_orm and settings.encryption_key:+ # Encrypt access token if present+ if self.access_token is not None:+ token_secret = Secret.from_plaintext(self.access_token)+ secret_dict = token_secret.to_dict()+ data["access_token_enc"] = secret_dict["encrypted"]+ # Keep plaintext for dual-write during migration+ data["access_token"] = secret_dict["plaintext"]++ # Encrypt refresh token if present+ if self.refresh_token is not None:+ token_secret = Secret.from_plaintext(self.refresh_token)+ secret_dict = token_secret.to_dict()+ data["refresh_token_enc"] = secret_dict["encrypted"]+ # Keep plaintext for dual-write during migration+ data["refresh_token"] = secret_dict["plaintext"]++ # Encrypt client secret if present+ if self.client_secret is not None:+ secret = Secret.from_plaintext(self.client_secret)+ secret_dict = secret.to_dict()+ data["client_secret_enc"] = secret_dict["encrypted"]+ # Keep plaintext for dual-write during migration+ data["client_secret"] = secret_dict["plaintext"]return datadiff --git a/letta/schemas/secret.py b/letta/schemas/secret.pyindex fe2c7cf04..6cba8249a 100644--- a/letta/schemas/secret.py+++ b/letta/schemas/secret.py@@ -118,8 +118,8 @@ class Secret(BaseModel):# Decrypt and cachetry:plaintext = CryptoUtils.decrypt(self._encrypted_value)- # Note: We can't actually cache due to frozen=True, but in practice- # we'll create new instances rather than mutating+ # Cache the decrypted value (PrivateAttr fields can be mutated even with frozen=True)+ self._plaintext_cache = plaintextreturn plaintextexcept Exception:# If decryption fails and this wasn't originally encrypted,@@ -224,9 +224,16 @@ class SecretDict(BaseModel):if self._encrypted_value is None:return None+ # Use cached value if available+ if self._plaintext_cache is not None:+ return self._plaintext_cache+try:decrypted_json = CryptoUtils.decrypt(self._encrypted_value)- return json.loads(decrypted_json)+ plaintext_dict = json.loads(decrypted_json)+ # Cache the decrypted value (PrivateAttr fields can be mutated even with frozen=True)+ self._plaintext_cache = plaintext_dict+ return plaintext_dictexcept Exception:if not self._was_encrypted:return Nonediff --git a/letta/services/mcp_manager.py b/letta/services/mcp_manager.pyindex 08bf38a4a..89e320a31 100644--- a/letta/services/mcp_manager.py+++ b/letta/services/mcp_manager.py@@ -755,55 +755,33 @@ class MCPManager:"""Convert OAuth ORM model to Pydantic model, handling decryption of sensitive fields."""- # Check for encryption key from env or settings- import os-from letta.settings import settings- encryption_key = os.environ.get("LETTA_ENCRYPTION_KEY") or settings.encryption_key-# Get decrypted values using the dual-read approach+ # Secret.from_db() will automatically use settings.encryption_key if availableaccess_token = Noneif oauth_session.access_token_enc or oauth_session.access_token:- if encryption_key:- # Temporarily set the key for Secret- original_key = settings.encryption_key- settings.encryption_key = encryption_key- try:- secret = Secret.from_db(oauth_session.access_token_enc, oauth_session.access_token)- access_token = secret.get_plaintext()- finally:- settings.encryption_key = original_key+ if settings.encryption_key:+ secret = Secret.from_db(oauth_session.access_token_enc, oauth_session.access_token)+ access_token = secret.get_plaintext()else:# No encryption key, use plaintext if availableaccess_token = oauth_session.access_tokenrefresh_token = Noneif oauth_session.refresh_token_enc or oauth_session.refresh_token:- if encryption_key:- # Temporarily set the key for Secret- original_key = settings.encryption_key- settings.encryption_key = encryption_key- try:- secret = Secret.from_db(oauth_session.refresh_token_enc, oauth_session.refresh_token)- refresh_token = secret.get_plaintext()- finally:- settings.encryption_key = original_key+ if settings.encryption_key:+ secret = Secret.from_db(oauth_session.refresh_token_enc, oauth_session.refresh_token)+ refresh_token = secret.get_plaintext()else:# No encryption key, use plaintext if availablerefresh_token = oauth_session.refresh_tokenclient_secret = Noneif oauth_session.client_secret_enc or oauth_session.client_secret:- if encryption_key:- # Temporarily set the key for Secret- original_key = settings.encryption_key- settings.encryption_key = encryption_key- try:- secret = Secret.from_db(oauth_session.client_secret_enc, oauth_session.client_secret)- client_secret = secret.get_plaintext()- finally:- settings.encryption_key = original_key+ if settings.encryption_key:+ secret = Secret.from_db(oauth_session.client_secret_enc, oauth_session.client_secret)+ client_secret = secret.get_plaintext()else:# No encryption key, use plaintext if availableclient_secret = oauth_session.client_secret@@ -900,25 +878,14 @@ class MCPManager:# Handle encryption for access_tokenif session_update.access_token is not None:- # Check for encryption key from env or settings- import os-from letta.settings import settings- encryption_key = os.environ.get("LETTA_ENCRYPTION_KEY") or settings.encryption_key-- if encryption_key:- # Temporarily set the key for Secret- original_key = settings.encryption_key- settings.encryption_key = encryption_key- try:- token_secret = Secret.from_plaintext(session_update.access_token)- secret_dict = token_secret.to_dict()- oauth_session.access_token_enc = secret_dict["encrypted"]- # During migration phase, also update plaintext- oauth_session.access_token = secret_dict["plaintext"] if not token_secret._was_encrypted else None- finally:- settings.encryption_key = original_key+ if settings.encryption_key:+ token_secret = Secret.from_plaintext(session_update.access_token)+ secret_dict = token_secret.to_dict()+ oauth_session.access_token_enc = secret_dict["encrypted"]+ # During migration phase, also update plaintext+ oauth_session.access_token = secret_dict["plaintext"] if not token_secret._was_encrypted else Noneelse:# No encryption, store plaintextoauth_session.access_token = session_update.access_token@@ -926,25 +893,14 @@ class MCPManager:# Handle encryption for refresh_tokenif session_update.refresh_token is not None:- # Check for encryption key from env or settings- import os-from letta.settings import settings- encryption_key = os.environ.get("LETTA_ENCRYPTION_KEY") or settings.encryption_key-- if encryption_key:- # Temporarily set the key for Secret- original_key = settings.encryption_key- settings.encryption_key = encryption_key- try:- token_secret = Secret.from_plaintext(session_update.refresh_token)- secret_dict = token_secret.to_dict()- oauth_session.refresh_token_enc = secret_dict["encrypted"]- # During migration phase, also update plaintext- oauth_session.refresh_token = secret_dict["plaintext"] if not token_secret._was_encrypted else None- finally:- settings.encryption_key = original_key+ if settings.encryption_key:+ token_secret = Secret.from_plaintext(session_update.refresh_token)+ secret_dict = token_secret.to_dict()+ oauth_session.refresh_token_enc = secret_dict["encrypted"]+ # During migration phase, also update plaintext+ oauth_session.refresh_token = secret_dict["plaintext"] if not token_secret._was_encrypted else Noneelse:# No encryption, store plaintextoauth_session.refresh_token = session_update.refresh_token@@ -961,25 +917,14 @@ class MCPManager:# Handle encryption for client_secretif session_update.client_secret is not None:- # Check for encryption key from env or settings- import os-from letta.settings import settings- encryption_key = os.environ.get("LETTA_ENCRYPTION_KEY") or settings.encryption_key-- if encryption_key:- # Temporarily set the key for Secret- original_key = settings.encryption_key- settings.encryption_key = encryption_key- try:- secret_secret = Secret.from_plaintext(session_update.client_secret)- secret_dict = secret_secret.to_dict()- oauth_session.client_secret_enc = secret_dict["encrypted"]- # During migration phase, also update plaintext- oauth_session.client_secret = secret_dict["plaintext"] if not secret_secret._was_encrypted else None- finally:- settings.encryption_key = original_key+ if settings.encryption_key:+ secret_secret = Secret.from_plaintext(session_update.client_secret)+ secret_dict = secret_secret.to_dict()+ oauth_session.client_secret_enc = secret_dict["encrypted"]+ # During migration phase, also update plaintext+ oauth_session.client_secret = secret_dict["plaintext"] if not secret_secret._was_encrypted else Noneelse:# No encryption, store plaintextoauth_session.client_secret = session_update.client_secretdiff --git a/tests/test_mcp_encryption.py b/tests/test_mcp_encryption.pyindex bcd2e827d..cec05c3ac 100644--- a/tests/test_mcp_encryption.py+++ b/tests/test_mcp_encryption.py@@ -17,6 +17,7 @@ from letta.helpers.crypto_utils import CryptoUtilsfrom letta.orm import MCPOAuth, MCPServer as ORMMCPServerfrom letta.schemas.mcp import (MCPOAuthSessionCreate,+ MCPOAuthSessionUpdate,MCPServer as PydanticMCPServer,MCPServerType,SSEServerConfig,@@ -26,6 +27,7 @@ from letta.schemas.secret import Secret, SecretDictfrom letta.server.db import db_registryfrom letta.server.server import SyncServerfrom letta.services.mcp_manager import MCPManager+from letta.settings import settings@pytest.fixture(scope="module")@@ -43,136 +45,152 @@ class TestMCPServerEncryption:MOCK_ENCRYPTION_KEY = "test-mcp-encryption-key-123456"@pytest.mark.asyncio- @patch.dict(os.environ, {"LETTA_ENCRYPTION_KEY": MOCK_ENCRYPTION_KEY})@patch("letta.services.mcp_manager.MCPManager.get_mcp_client")async def test_create_mcp_server_with_token_encryption(self, mock_get_client, server, default_user):"""Test that MCP server tokens are encrypted when stored."""- # Mock the MCP client- mock_client = AsyncMock()- mock_client.list_tools.return_value = []- mock_get_client.return_value = mock_client+ # Set encryption key directly on settings+ original_key = settings.encryption_key+ settings.encryption_key = self.MOCK_ENCRYPTION_KEY++ try:+ # Mock the MCP client+ mock_client = AsyncMock()+ mock_client.list_tools.return_value = []+ mock_get_client.return_value = mock_client- # Create MCP server with token- server_name = f"test_encrypted_server_{uuid4().hex[:8]}"- token = "super-secret-api-token-12345"- server_url = "https://api.example.com/mcp"+ # Create MCP server with token+ server_name = f"test_encrypted_server_{uuid4().hex[:8]}"+ token = "super-secret-api-token-12345"+ server_url = "https://api.example.com/mcp"- mcp_server = PydanticMCPServer(server_name=server_name, server_type=MCPServerType.SSE, server_url=server_url, token=token)+ mcp_server = PydanticMCPServer(server_name=server_name, server_type=MCPServerType.SSE, server_url=server_url, token=token)- created_server = await server.mcp_manager.create_or_update_mcp_server(mcp_server, actor=default_user)+ created_server = await server.mcp_manager.create_or_update_mcp_server(mcp_server, actor=default_user)- # Verify server was created- assert created_server.server_name == server_name- assert created_server.server_type == MCPServerType.SSE+ # Verify server was created+ assert created_server.server_name == server_name+ assert created_server.server_type == MCPServerType.SSE- # Check database directly to verify encryption- async with db_registry.async_session() as session:- result = await session.execute(select(ORMMCPServer).where(ORMMCPServer.id == created_server.id))- db_server = result.scalar_one()+ # Check database directly to verify encryption+ async with db_registry.async_session() as session:+ result = await session.execute(select(ORMMCPServer).where(ORMMCPServer.id == created_server.id))+ db_server = result.scalar_one()- # Token should be encrypted in database- assert db_server.token_enc is not None- assert db_server.token_enc != token # Should not be plaintext+ # Token should be encrypted in database+ assert db_server.token_enc is not None+ assert db_server.token_enc != token # Should not be plaintext- # Decrypt to verify correctness- decrypted_token = CryptoUtils.decrypt(db_server.token_enc, self.MOCK_ENCRYPTION_KEY)- assert decrypted_token == token+ # Decrypt to verify correctness+ decrypted_token = CryptoUtils.decrypt(db_server.token_enc)+ assert decrypted_token == token- # Legacy plaintext column should be None (or empty for dual-write)- # During migration phase, might store both- if db_server.token:- assert db_server.token == token # Dual-write phase+ # Legacy plaintext column should be None (or empty for dual-write)+ # During migration phase, might store both+ if db_server.token:+ assert db_server.token == token # Dual-write phase- # Clean up- await server.mcp_manager.delete_mcp_server_by_id(created_server.id, actor=default_user)+ # Clean up+ await server.mcp_manager.delete_mcp_server_by_id(created_server.id, actor=default_user)++ finally:+ # Restore original encryption key+ settings.encryption_key = original_key@pytest.mark.asyncio- @patch.dict(os.environ, {"LETTA_ENCRYPTION_KEY": MOCK_ENCRYPTION_KEY})@patch("letta.services.mcp_manager.MCPManager.get_mcp_client")async def test_create_mcp_server_with_custom_headers_encryption(self, mock_get_client, server, default_user):"""Test that MCP server custom headers are encrypted when stored."""- # Mock the MCP client- mock_client = AsyncMock()- mock_client.list_tools.return_value = []- mock_get_client.return_value = mock_client+ # Set encryption key directly on settings+ original_key = settings.encryption_key+ settings.encryption_key = self.MOCK_ENCRYPTION_KEY- server_name = f"test_headers_server_{uuid4().hex[:8]}"- custom_headers = {"Authorization": "Bearer secret-token-xyz", "X-API-Key": "api-key-123456", "X-Custom-Header": "custom-value"}- server_url = "https://api.example.com/mcp"+ try:+ # Mock the MCP client+ mock_client = AsyncMock()+ mock_client.list_tools.return_value = []+ mock_get_client.return_value = mock_client- mcp_server = PydanticMCPServer(- server_name=server_name, server_type=MCPServerType.STREAMABLE_HTTP, server_url=server_url, custom_headers=custom_headers- )+ server_name = f"test_headers_server_{uuid4().hex[:8]}"+ custom_headers = {"Authorization": "Bearer secret-token-xyz", "X-API-Key": "api-key-123456", "X-Custom-Header": "custom-value"}+ server_url = "https://api.example.com/mcp"- created_server = await server.mcp_manager.create_or_update_mcp_server(mcp_server, actor=default_user)+ mcp_server = PydanticMCPServer(+ server_name=server_name, server_type=MCPServerType.STREAMABLE_HTTP, server_url=server_url, custom_headers=custom_headers+ )- # Check database directly- async with db_registry.async_session() as session:- result = await session.execute(select(ORMMCPServer).where(ORMMCPServer.id == created_server.id))- db_server = result.scalar_one()+ created_server = await server.mcp_manager.create_or_update_mcp_server(mcp_server, actor=default_user)- # Custom headers should be encrypted as JSON- assert db_server.custom_headers_enc is not None+ # Check database directly+ async with db_registry.async_session() as session:+ result = await session.execute(select(ORMMCPServer).where(ORMMCPServer.id == created_server.id))+ db_server = result.scalar_one()- # Decrypt and parse JSON- decrypted_json = CryptoUtils.decrypt(db_server.custom_headers_enc, self.MOCK_ENCRYPTION_KEY)- decrypted_headers = json.loads(decrypted_json)- assert decrypted_headers == custom_headers+ # Custom headers should be encrypted as JSON+ assert db_server.custom_headers_enc is not None- # Clean up- await server.mcp_manager.delete_mcp_server_by_id(created_server.id, actor=default_user)+ # Decrypt and parse JSON+ decrypted_json = CryptoUtils.decrypt(db_server.custom_headers_enc)+ decrypted_headers = json.loads(decrypted_json)+ assert decrypted_headers == custom_headers++ # Clean up+ await server.mcp_manager.delete_mcp_server_by_id(created_server.id, actor=default_user)++ finally:+ # Restore original encryption key+ settings.encryption_key = original_key@pytest.mark.asyncio- @patch.dict(os.environ, {"LETTA_ENCRYPTION_KEY": MOCK_ENCRYPTION_KEY})async def test_retrieve_mcp_server_decrypts_values(self, server, default_user):"""Test that retrieving MCP server decrypts encrypted values."""- # Manually insert encrypted server into database- server_id = f"mcp_server-{uuid4().hex[:8]}"- server_name = f"test_decrypt_server_{uuid4().hex[:8]}"- plaintext_token = "decryption-test-token"- encrypted_token = CryptoUtils.encrypt(plaintext_token, self.MOCK_ENCRYPTION_KEY)-- async with db_registry.async_session() as session:- db_server = ORMMCPServer(- id=server_id,- server_name=server_name,- server_type=MCPServerType.SSE.value,- server_url="https://test.com",- token_enc=encrypted_token,- token=None, # No plaintext- created_by_id=default_user.id,- last_updated_by_id=default_user.id,- organization_id=default_user.organization_id,- created_at=datetime.now(timezone.utc),- updated_at=datetime.now(timezone.utc),- )- session.add(db_server)- await session.commit()-- # Retrieve server directly by ID to avoid issues with other servers in DB- test_server = await server.mcp_manager.get_mcp_server_by_id_async(server_id, actor=default_user)-- assert test_server is not None- assert test_server.server_name == server_name- # Token should be decrypted when accessed via the secret method- # Ensure encryption key is available for decryption- from letta.settings import settings-+ # Set encryption key directly on settingsoriginal_key = settings.encryption_keysettings.encryption_key = self.MOCK_ENCRYPTION_KEY+try:+ # Manually insert encrypted server into database+ server_id = f"mcp_server-{uuid4().hex[:8]}"+ server_name = f"test_decrypt_server_{uuid4().hex[:8]}"+ plaintext_token = "decryption-test-token"+ encrypted_token = CryptoUtils.encrypt(plaintext_token)++ async with db_registry.async_session() as session:+ db_server = ORMMCPServer(+ id=server_id,+ server_name=server_name,+ server_type=MCPServerType.SSE.value,+ server_url="https://test.com",+ token_enc=encrypted_token,+ token=None, # No plaintext+ created_by_id=default_user.id,+ last_updated_by_id=default_user.id,+ organization_id=default_user.organization_id,+ created_at=datetime.now(timezone.utc),+ updated_at=datetime.now(timezone.utc),+ )+ session.add(db_server)+ await session.commit()++ # Retrieve server directly by ID to avoid issues with other servers in DB+ test_server = await server.mcp_manager.get_mcp_server_by_id_async(server_id, actor=default_user)++ assert test_server is not None+ assert test_server.server_name == server_name+ # Token should be decrypted when accessed via the secret methodtoken_secret = test_server.get_token_secret()assert token_secret.get_plaintext() == plaintext_token++ # Clean up+ async with db_registry.async_session() as session:+ result = await session.execute(select(ORMMCPServer).where(ORMMCPServer.id == server_id))+ db_server = result.scalar_one()+ await session.delete(db_server)+ await session.commit()+finally:+ # Restore original encryption keysettings.encryption_key = original_key- # Clean up- async with db_registry.async_session() as session:- result = await session.execute(select(ORMMCPServer).where(ORMMCPServer.id == server_id))- db_server = result.scalar_one()- await session.delete(db_server)- await session.commit()-@pytest.mark.asyncio@patch.dict(os.environ, {}, clear=True) # No encryption key@patch("letta.services.mcp_manager.MCPManager.get_mcp_client")@@ -214,194 +232,222 @@ class TestMCPOAuthEncryption:MOCK_ENCRYPTION_KEY = "test-oauth-encryption-key-123456"@pytest.mark.asyncio- @patch.dict(os.environ, {"LETTA_ENCRYPTION_KEY": MOCK_ENCRYPTION_KEY})async def test_create_oauth_session_with_encryption(self, server, default_user):"""Test that OAuth tokens are encrypted when stored."""- server_url = "https://github.com/mcp"- server_name = "GitHub MCP"-- # Step 1: Create OAuth session (without tokens initially)- oauth_session_create = MCPOAuthSessionCreate(- server_url=server_url,- server_name=server_name,- organization_id=default_user.organization_id,- user_id=default_user.id,- )+ # Set encryption key directly on settings+ original_key = settings.encryption_key+ settings.encryption_key = self.MOCK_ENCRYPTION_KEY++ try:+ server_url = "https://github.com/mcp"+ server_name = "GitHub MCP"- created_session = await server.mcp_manager.create_oauth_session(oauth_session_create, actor=default_user)+ # Step 1: Create OAuth session (without tokens initially)+ oauth_session_create = MCPOAuthSessionCreate(+ server_url=server_url,+ server_name=server_name,+ organization_id=default_user.organization_id,+ user_id=default_user.id,+ )- assert created_session.server_url == server_url- assert created_session.server_name == server_name+ created_session = await server.mcp_manager.create_oauth_session(oauth_session_create, actor=default_user)- # Step 2: Update session with tokens (simulating OAuth callback)- from letta.schemas.mcp import MCPOAuthSessionUpdate+ assert created_session.server_url == server_url+ assert created_session.server_name == server_name- update_data = MCPOAuthSessionUpdate(- access_token="github-access-token-abc123",- refresh_token="github-refresh-token-xyz789",- client_id="client-id-123",- client_secret="client-secret-super-secret",- expires_at=datetime.now(timezone.utc),- )+ # Step 2: Update session with tokens (simulating OAuth callback)+ update_data = MCPOAuthSessionUpdate(+ access_token="github-access-token-abc123",+ refresh_token="github-refresh-token-xyz789",+ client_id="client-id-123",+ client_secret="client-secret-super-secret",+ expires_at=datetime.now(timezone.utc),+ )- await server.mcp_manager.update_oauth_session(created_session.id, update_data, actor=default_user)+ await server.mcp_manager.update_oauth_session(created_session.id, update_data, actor=default_user)- # Check database directly for encryption- async with db_registry.async_session() as session:- result = await session.execute(select(MCPOAuth).where(MCPOAuth.id == created_session.id))- db_oauth = result.scalar_one()+ # Check database directly for encryption+ async with db_registry.async_session() as session:+ result = await session.execute(select(MCPOAuth).where(MCPOAuth.id == created_session.id))+ db_oauth = result.scalar_one()++ # All sensitive fields should be encrypted+ assert db_oauth.access_token_enc is not None+ assert db_oauth.access_token_enc != update_data.access_token- # All sensitive fields should be encrypted- assert db_oauth.access_token_enc is not None- assert db_oauth.access_token_enc != update_data.access_token+ assert db_oauth.refresh_token_enc is not None- assert db_oauth.refresh_token_enc is not None+ assert db_oauth.client_secret_enc is not None- assert db_oauth.client_secret_enc is not None+ # Verify decryption+ decrypted_access = CryptoUtils.decrypt(db_oauth.access_token_enc)+ assert decrypted_access == update_data.access_token- # Verify decryption- decrypted_access = CryptoUtils.decrypt(db_oauth.access_token_enc, self.MOCK_ENCRYPTION_KEY)- assert decrypted_access == update_data.access_token+ decrypted_refresh = CryptoUtils.decrypt(db_oauth.refresh_token_enc)+ assert decrypted_refresh == update_data.refresh_token- decrypted_refresh = CryptoUtils.decrypt(db_oauth.refresh_token_enc, self.MOCK_ENCRYPTION_KEY)- assert decrypted_refresh == update_data.refresh_token+ decrypted_secret = CryptoUtils.decrypt(db_oauth.client_secret_enc)+ assert decrypted_secret == update_data.client_secret- decrypted_secret = CryptoUtils.decrypt(db_oauth.client_secret_enc, self.MOCK_ENCRYPTION_KEY)- assert decrypted_secret == update_data.client_secret+ finally:+ # Restore original encryption key+ settings.encryption_key = original_key# Clean up not needed - test database is reset@pytest.mark.asyncio- @patch.dict(os.environ, {"LETTA_ENCRYPTION_KEY": MOCK_ENCRYPTION_KEY})async def test_retrieve_oauth_session_decrypts_tokens(self, server, default_user):"""Test that retrieving OAuth session decrypts tokens."""- # Manually insert encrypted OAuth session- session_id = f"mcp-oauth-{str(uuid4())[:8]}"- access_token = "test-access-token"- refresh_token = "test-refresh-token"- client_secret = "test-client-secret"-- encrypted_access = CryptoUtils.encrypt(access_token, self.MOCK_ENCRYPTION_KEY)- encrypted_refresh = CryptoUtils.encrypt(refresh_token, self.MOCK_ENCRYPTION_KEY)- encrypted_secret = CryptoUtils.encrypt(client_secret, self.MOCK_ENCRYPTION_KEY)-- async with db_registry.async_session() as session:- db_oauth = MCPOAuth(- id=session_id,- state=f"test-state-{uuid4().hex[:8]}",- server_url="https://test.com/mcp",- server_name="Test Provider",- access_token_enc=encrypted_access,- refresh_token_enc=encrypted_refresh,- client_id="test-client",- client_secret_enc=encrypted_secret,- user_id=default_user.id,- organization_id=default_user.organization_id,- created_at=datetime.now(timezone.utc),- updated_at=datetime.now(timezone.utc),- )- session.add(db_oauth)- await session.commit()-- # Retrieve through manager by ID- test_session = await server.mcp_manager.get_oauth_session_by_id(session_id, actor=default_user)- assert test_session is not None+ # Set encryption key directly on settings+ original_key = settings.encryption_key+ settings.encryption_key = self.MOCK_ENCRYPTION_KEY- # Tokens should be decrypted- assert test_session.access_token == access_token- assert test_session.refresh_token == refresh_token- assert test_session.client_secret == client_secret+ try:+ # Manually insert encrypted OAuth session+ session_id = f"mcp-oauth-{str(uuid4())[:8]}"+ access_token = "test-access-token"+ refresh_token = "test-refresh-token"+ client_secret = "test-client-secret"++ encrypted_access = CryptoUtils.encrypt(access_token)+ encrypted_refresh = CryptoUtils.encrypt(refresh_token)+ encrypted_secret = CryptoUtils.encrypt(client_secret)++ async with db_registry.async_session() as session:+ db_oauth = MCPOAuth(+ id=session_id,+ state=f"test-state-{uuid4().hex[:8]}",+ server_url="https://test.com/mcp",+ server_name="Test Provider",+ access_token_enc=encrypted_access,+ refresh_token_enc=encrypted_refresh,+ client_id="test-client",+ client_secret_enc=encrypted_secret,+ user_id=default_user.id,+ organization_id=default_user.organization_id,+ created_at=datetime.now(timezone.utc),+ updated_at=datetime.now(timezone.utc),+ )+ session.add(db_oauth)+ await session.commit()++ # Retrieve through manager by ID+ test_session = await server.mcp_manager.get_oauth_session_by_id(session_id, actor=default_user)+ assert test_session is not None++ # Tokens should be decrypted+ assert test_session.access_token == access_token+ assert test_session.refresh_token == refresh_token+ assert test_session.client_secret == client_secret++ # Clean up not needed - test database is reset- # Clean up not needed - test database is reset+ finally:+ # Restore original encryption key+ settings.encryption_key = original_key@pytest.mark.asyncio- @patch.dict(os.environ, {"LETTA_ENCRYPTION_KEY": MOCK_ENCRYPTION_KEY})async def test_update_oauth_session_maintains_encryption(self, server, default_user):"""Test that updating OAuth session maintains encryption."""- # Create initial session (without tokens)- from letta.schemas.mcp import MCPOAuthSessionUpdate-- oauth_session_create = MCPOAuthSessionCreate(- server_url="https://test.com/mcp",- server_name="Test Update Provider",- organization_id=default_user.organization_id,- user_id=default_user.id,- )+ # Set encryption key directly on settings+ original_key = settings.encryption_key+ settings.encryption_key = self.MOCK_ENCRYPTION_KEY- created_session = await server.mcp_manager.create_oauth_session(oauth_session_create, actor=default_user)+ try:+ # Create initial session (without tokens)+ oauth_session_create = MCPOAuthSessionCreate(+ server_url="https://test.com/mcp",+ server_name="Test Update Provider",+ organization_id=default_user.organization_id,+ user_id=default_user.id,+ )- # Add initial tokens- initial_update = MCPOAuthSessionUpdate(- access_token="initial-token",- refresh_token="initial-refresh",- client_id="client-123",- client_secret="initial-secret",- )+ created_session = await server.mcp_manager.create_oauth_session(oauth_session_create, actor=default_user)++ # Add initial tokens+ initial_update = MCPOAuthSessionUpdate(+ access_token="initial-token",+ refresh_token="initial-refresh",+ client_id="client-123",+ client_secret="initial-secret",+ )- await server.mcp_manager.update_oauth_session(created_session.id, initial_update, actor=default_user)+ await server.mcp_manager.update_oauth_session(created_session.id, initial_update, actor=default_user)- # Update with new tokens- new_access_token = "updated-access-token"- new_refresh_token = "updated-refresh-token"+ # Update with new tokens+ new_access_token = "updated-access-token"+ new_refresh_token = "updated-refresh-token"- new_update = MCPOAuthSessionUpdate(- access_token=new_access_token,- refresh_token=new_refresh_token,- )+ new_update = MCPOAuthSessionUpdate(+ access_token=new_access_token,+ refresh_token=new_refresh_token,+ )- updated_session = await server.mcp_manager.update_oauth_session(created_session.id, new_update, actor=default_user)+ updated_session = await server.mcp_manager.update_oauth_session(created_session.id, new_update, actor=default_user)- # Verify update worked- assert updated_session.access_token == new_access_token- assert updated_session.refresh_token == new_refresh_token+ # Verify update worked+ assert updated_session.access_token == new_access_token+ assert updated_session.refresh_token == new_refresh_token- # Check database encryption- async with db_registry.async_session() as session:- result = await session.execute(select(MCPOAuth).where(MCPOAuth.id == created_session.id))- db_oauth = result.scalar_one()+ # Check database encryption+ async with db_registry.async_session() as session:+ result = await session.execute(select(MCPOAuth).where(MCPOAuth.id == created_session.id))+ db_oauth = result.scalar_one()- # New tokens should be encrypted- decrypted_access = CryptoUtils.decrypt(db_oauth.access_token_enc, self.MOCK_ENCRYPTION_KEY)- assert decrypted_access == new_access_token+ # New tokens should be encrypted+ decrypted_access = CryptoUtils.decrypt(db_oauth.access_token_enc)+ assert decrypted_access == new_access_token- decrypted_refresh = CryptoUtils.decrypt(db_oauth.refresh_token_enc, self.MOCK_ENCRYPTION_KEY)- assert decrypted_refresh == new_refresh_token+ decrypted_refresh = CryptoUtils.decrypt(db_oauth.refresh_token_enc)+ assert decrypted_refresh == new_refresh_token- # Clean up not needed - test database is reset+ # Clean up not needed - test database is reset++ finally:+ # Restore original encryption key+ settings.encryption_key = original_key@pytest.mark.asyncio- @patch.dict(os.environ, {"LETTA_ENCRYPTION_KEY": MOCK_ENCRYPTION_KEY})async def test_dual_read_backward_compatibility(self, server, default_user):"""Test that system can read both encrypted and plaintext values (migration support)."""- # Insert a record with both encrypted and plaintext values- session_id = f"mcp-oauth-{str(uuid4())[:8]}"- plaintext_token = "legacy-plaintext-token"- new_encrypted_token = "new-encrypted-token"- encrypted_new = CryptoUtils.encrypt(new_encrypted_token, self.MOCK_ENCRYPTION_KEY)-- async with db_registry.async_session() as session:- db_oauth = MCPOAuth(- id=session_id,- state=f"dual-read-state-{uuid4().hex[:8]}",- server_url="https://test.com/mcp",- server_name="Dual Read Test",- # Both encrypted and plaintext values- access_token=plaintext_token, # Legacy plaintext- access_token_enc=encrypted_new, # New encrypted- client_id="test-client",- user_id=default_user.id,- organization_id=default_user.organization_id,- created_at=datetime.now(timezone.utc),- updated_at=datetime.now(timezone.utc),- )- session.add(db_oauth)- await session.commit()-- # Retrieve through manager- test_session = await server.mcp_manager.get_oauth_session_by_id(session_id, actor=default_user)- assert test_session is not None+ # Set encryption key directly on settings+ original_key = settings.encryption_key+ settings.encryption_key = self.MOCK_ENCRYPTION_KEY- # Should prefer encrypted value over plaintext- assert test_session.access_token == new_encrypted_token+ try:+ # Insert a record with both encrypted and plaintext values+ session_id = f"mcp-oauth-{str(uuid4())[:8]}"+ plaintext_token = "legacy-plaintext-token"+ new_encrypted_token = "new-encrypted-token"+ encrypted_new = CryptoUtils.encrypt(new_encrypted_token)++ async with db_registry.async_session() as session:+ db_oauth = MCPOAuth(+ id=session_id,+ state=f"dual-read-state-{uuid4().hex[:8]}",+ server_url="https://test.com/mcp",+ server_name="Dual Read Test",+ # Both encrypted and plaintext values+ access_token=plaintext_token, # Legacy plaintext+ access_token_enc=encrypted_new, # New encrypted+ client_id="test-client",+ user_id=default_user.id,+ organization_id=default_user.organization_id,+ created_at=datetime.now(timezone.utc),+ updated_at=datetime.now(timezone.utc),+ )+ session.add(db_oauth)+ await session.commit()++ # Retrieve through manager+ test_session = await server.mcp_manager.get_oauth_session_by_id(session_id, actor=default_user)+ assert test_session is not None++ # Should prefer encrypted value over plaintext+ assert test_session.access_token == new_encrypted_token++ # Clean up not needed - test database is reset- # Clean up not needed - test database is reset+ finally:+ # Restore original encryption key+ settings.encryption_key = original_keydiff --git a/tests/test_secret.py b/tests/test_secret.pyindex a273344f7..595339182 100644--- a/tests/test_secret.py+++ b/tests/test_secret.py@@ -1,4 +1,5 @@import json+from unittest.mock import MagicMock, patchimport pytest@@ -219,6 +220,61 @@ class TestSecret:finally:settings.encryption_key = original_key+ def test_plaintext_caching(self):+ """Test that plaintext values are cached after first decryption."""+ from letta.settings import settings++ original_key = settings.encryption_key+ settings.encryption_key = self.MOCK_KEY++ try:+ plaintext = "cached-value"+ secret = Secret.from_plaintext(plaintext)++ # First call should decrypt and cache+ result1 = secret.get_plaintext()+ assert result1 == plaintext+ assert secret._plaintext_cache == plaintext++ # Second call should use cache+ result2 = secret.get_plaintext()+ assert result2 == plaintext+ assert result1 is result2 # Should be the same object reference+ finally:+ settings.encryption_key = original_key++ def test_caching_only_decrypts_once(self):+ """Test that decryption only happens once when caching is enabled."""+ from letta.settings import settings++ original_key = settings.encryption_key+ settings.encryption_key = self.MOCK_KEY++ try:+ plaintext = "test-single-decrypt"+ encrypted = CryptoUtils.encrypt(plaintext, self.MOCK_KEY)++ # Create a Secret from encrypted value+ secret = Secret.from_encrypted(encrypted)++ # Mock the decrypt method to track calls+ with patch.object(CryptoUtils, "decrypt", wraps=CryptoUtils.decrypt) as mock_decrypt:+ # First call should decrypt+ result1 = secret.get_plaintext()+ assert result1 == plaintext+ assert mock_decrypt.call_count == 1++ # Second and third calls should use cache+ result2 = secret.get_plaintext()+ result3 = secret.get_plaintext()+ assert result2 == plaintext+ assert result3 == plaintext++ # Decrypt should still have been called only once+ assert mock_decrypt.call_count == 1+ finally:+ settings.encryption_key = original_key+class TestSecretDict:"""Test suite for SecretDict wrapper class."""@@ -371,3 +427,71 @@ class TestSecretDict:assert secret_dict.get_plaintext() == new_dictfinally:settings.encryption_key = original_key++ def test_plaintext_dict_caching(self):+ """Test that plaintext dictionary values are cached after first decryption."""+ from letta.settings import settings++ original_key = settings.encryption_key+ settings.encryption_key = self.MOCK_KEY++ try:+ plaintext_dict = {"key1": "value1", "key2": "value2", "nested": {"inner": "value"}}+ secret_dict = SecretDict.from_plaintext(plaintext_dict)++ # First call should decrypt and cache+ result1 = secret_dict.get_plaintext()+ assert result1 == plaintext_dict+ assert secret_dict._plaintext_cache == plaintext_dict++ # Second call should use cache+ result2 = secret_dict.get_plaintext()+ assert result2 == plaintext_dict+ assert result1 is result2 # Should be the same object reference+ finally:+ settings.encryption_key = original_key++ def test_dict_caching_only_decrypts_once(self):+ """Test that SecretDict decryption only happens once when caching is enabled."""+ from letta.settings import settings++ original_key = settings.encryption_key+ settings.encryption_key = self.MOCK_KEY++ try:+ plaintext_dict = {"api_key": "sk-12345", "api_secret": "secret-value"}+ encrypted = CryptoUtils.encrypt(json.dumps(plaintext_dict), self.MOCK_KEY)++ # Create a SecretDict from encrypted value+ secret_dict = SecretDict.from_encrypted(encrypted)++ # Mock the decrypt method to track calls+ with patch.object(CryptoUtils, "decrypt", wraps=CryptoUtils.decrypt) as mock_decrypt:+ # First call should decrypt+ result1 = secret_dict.get_plaintext()+ assert result1 == plaintext_dict+ assert mock_decrypt.call_count == 1++ # Second and third calls should use cache+ result2 = secret_dict.get_plaintext()+ result3 = secret_dict.get_plaintext()+ assert result2 == plaintext_dict+ assert result3 == plaintext_dict++ # Decrypt should still have been called only once+ assert mock_decrypt.call_count == 1+ finally:+ settings.encryption_key = original_key++ def test_cache_handles_none_values(self):+ """Test that caching works correctly with None/empty values."""+ # Test with None value+ secret_dict = SecretDict.from_plaintext(None)++ # First call+ result1 = secret_dict.get_plaintext()+ assert result1 is None++ # Second call should also return None (not trying to decrypt)+ result2 = secret_dict.get_plaintext()+ assert result2 is None