Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.
feat: read from encrypted values with error on fallback [LET-4250] (#6484)
jnjpng89ca8fe8b058
diff --git a/letta/schemas/environment_variables.py b/letta/schemas/environment_variables.pyindex 9485bcb95..c1fd1b3b6 100644--- a/letta/schemas/environment_variables.py+++ b/letta/schemas/environment_variables.py@@ -21,12 +21,12 @@ class EnvironmentVariableBase(OrmMetadataBase):value_enc: Secret | None = Field(None, description="Encrypted value as Secret object")def get_value_secret(self) -> Secret:- """Get the value as a Secret object, preferring encrypted over plaintext."""+ """Get the value as a Secret object. Prefers encrypted, falls back to plaintext with error logging."""# If value_enc is already a Secret, return itif self.value_enc is not None:return self.value_enc- # Otherwise, create from plaintext value- return Secret.from_db(None, self.value)+ # Fallback to plaintext with error logging via Secret.from_db()+ return Secret.from_db(encrypted_value=None, plaintext_value=self.value)def set_value_secret(self, secret: Secret) -> None:"""Set value from a Secret object, directly storing the Secret."""diff --git a/letta/schemas/mcp.py b/letta/schemas/mcp.pyindex d40f9865b..85ab7e230 100644--- a/letta/schemas/mcp.py+++ b/letta/schemas/mcp.py@@ -49,20 +49,20 @@ class MCPServer(BaseMCPServer):metadata_: Optional[Dict[str, Any]] = Field(default_factory=dict, description="A dictionary of additional metadata for the tool.")def get_token_secret(self) -> Secret:- """Get the token as a Secret object, preferring encrypted over plaintext."""+ """Get the token as a Secret object. Prefers encrypted, falls back to plaintext with error logging."""if self.token_enc is not None:return self.token_enc- return Secret.from_db(None, self.token)+ # Fallback to plaintext with error logging via Secret.from_db()+ return Secret.from_db(encrypted_value=None, plaintext_value=self.token)def get_custom_headers_secret(self) -> Secret:- """Get custom headers as a Secret object (stores JSON string), preferring encrypted over plaintext."""+ """Get custom headers as a Secret object (stores JSON string). Prefers encrypted, falls back to plaintext with error logging."""if self.custom_headers_enc is not None:return self.custom_headers_enc- # Fallback: convert plaintext dict to JSON string and wrap in Secret- if self.custom_headers is not None:- json_str = json.dumps(self.custom_headers)- return Secret.from_plaintext(json_str)- return Secret.from_plaintext(None)+ # Fallback to plaintext with error logging via Secret.from_db()+ # Convert dict to JSON string for Secret storage+ plaintext_json = json.dumps(self.custom_headers) if self.custom_headers else None+ return Secret.from_db(encrypted_value=None, plaintext_value=plaintext_json)def get_custom_headers_dict(self) -> Optional[Dict[str, str]]:"""Get custom headers as a plaintext dictionary."""diff --git a/letta/schemas/mcp_server.py b/letta/schemas/mcp_server.pyindex 1094e497b..459292bcd 100644--- a/letta/schemas/mcp_server.py+++ b/letta/schemas/mcp_server.py@@ -165,28 +165,32 @@ class MCPOAuthSession(BaseMCPOAuth):updated_at: datetime = Field(default_factory=datetime.now, description="Last update time")def get_access_token_secret(self) -> Secret:- """Get the access token as a Secret object, preferring encrypted over plaintext."""+ """Get the access token as a Secret object. Prefers encrypted, falls back to plaintext with error logging."""if self.access_token_enc is not None:return self.access_token_enc- return Secret.from_db(None, self.access_token)+ # Fallback to plaintext with error logging via Secret.from_db()+ return Secret.from_db(encrypted_value=None, plaintext_value=self.access_token)def get_refresh_token_secret(self) -> Secret:- """Get the refresh token as a Secret object, preferring encrypted over plaintext."""+ """Get the refresh token as a Secret object. Prefers encrypted, falls back to plaintext with error logging."""if self.refresh_token_enc is not None:return self.refresh_token_enc- return Secret.from_db(None, self.refresh_token)+ # Fallback to plaintext with error logging via Secret.from_db()+ return Secret.from_db(encrypted_value=None, plaintext_value=self.refresh_token)def get_client_secret_secret(self) -> Secret:- """Get the client secret as a Secret object, preferring encrypted over plaintext."""+ """Get the client secret as a Secret object. Prefers encrypted, falls back to plaintext with error logging."""if self.client_secret_enc is not None:return self.client_secret_enc- return Secret.from_db(None, self.client_secret)+ # Fallback to plaintext with error logging via Secret.from_db()+ return Secret.from_db(encrypted_value=None, plaintext_value=self.client_secret)def get_authorization_code_secret(self) -> Secret:- """Get the authorization code as a Secret object, preferring encrypted over plaintext."""+ """Get the authorization code as a Secret object. Prefers encrypted, falls back to plaintext with error logging."""if self.authorization_code_enc is not None:return self.authorization_code_enc- return Secret.from_db(None, self.authorization_code)+ # Fallback to plaintext with error logging via Secret.from_db()+ return Secret.from_db(encrypted_value=None, plaintext_value=self.authorization_code)def set_access_token_secret(self, secret: Secret) -> None:"""Set access token from a Secret object."""diff --git a/letta/schemas/providers/base.py b/letta/schemas/providers/base.pyindex df9da6620..f9457c7d1 100644--- a/letta/schemas/providers/base.py+++ b/letta/schemas/providers/base.py@@ -50,20 +50,20 @@ class Provider(ProviderBase):self.id = ProviderBase.generate_id(prefix=ProviderBase.__id_prefix__)def get_api_key_secret(self) -> Secret:- """Get the API key as a Secret object, preferring encrypted over plaintext."""+ """Get the API key as a Secret object. Prefers encrypted, falls back to plaintext with error logging."""# If api_key_enc is already a Secret, return itif self.api_key_enc is not None:return self.api_key_enc- # Otherwise, create from plaintext api_key- return Secret.from_db(None, self.api_key)+ # Fallback to plaintext with error logging via Secret.from_db()+ return Secret.from_db(encrypted_value=None, plaintext_value=self.api_key)def get_access_key_secret(self) -> Secret:- """Get the access key as a Secret object, preferring encrypted over plaintext."""+ """Get the access key as a Secret object. Prefers encrypted, falls back to plaintext with error logging."""# If access_key_enc is already a Secret, return itif self.access_key_enc is not None:return self.access_key_enc- # Otherwise, create from plaintext access_key- return Secret.from_db(None, self.access_key)+ # Fallback to plaintext with error logging via Secret.from_db()+ return Secret.from_db(encrypted_value=None, plaintext_value=self.access_key)def set_api_key_secret(self, secret: Secret) -> None:"""Set API key from a Secret object, directly storing the Secret."""diff --git a/letta/schemas/secret.py b/letta/schemas/secret.pyindex 687b88962..be59c1c1e 100644--- a/letta/schemas/secret.py+++ b/letta/schemas/secret.py@@ -17,11 +17,14 @@ class Secret(BaseModel):This class ensures that sensitive data remains encrypted as much as possiblewhile passing through the codebase, only decrypting when absolutely necessary.- TODO: Once we deprecate plaintext columns in the database:- - Remove the dual-write logic in to_dict()- - Remove the from_db() method's plaintext_value parameter- - Remove the was_encrypted flag (no longer needed for migration)- - Simplify get_plaintext() to only handle encrypted values+ Migration status (Phase 1 - encrypted-first reads with plaintext fallback):+ - Reads: Prefer _enc columns, fallback to plaintext columns with ERROR logging+ - Writes: Still dual-write to both _enc and plaintext columns for backward compatibility+ - Encryption: Optional - if LETTA_ENCRYPTION_KEY is not set, stores plaintext in _enc column++ TODO (Phase 2): Remove plaintext fallback in from_db() after verifying no error logs+ TODO (Phase 3): Remove dual-write logic in to_dict() and set_*_secret() methods+ TODO (Phase 4): Remove from_db() plaintext_value parameter, was_encrypted flag, and plaintext columns"""# Store the encrypted value as a regular field@@ -38,11 +41,14 @@ class Secret(BaseModel):"""Create a Secret from a plaintext value, encrypting it if possible.+ If LETTA_ENCRYPTION_KEY is configured, the value is encrypted.+ If not, the plaintext value is stored directly in encrypted_value field.+Args:value: The plaintext value to encryptReturns:- A Secret instance with the encrypted value, or plaintext if encryption unavailable+ A Secret instance with the encrypted (or plaintext) value"""if value is None:return cls.model_construct(encrypted_value=None, was_encrypted=False)@@ -51,19 +57,19 @@ class Secret(BaseModel):if CryptoUtils.is_encrypted(value):logger.warning("Creating Secret from already-encrypted value. This can be dangerous.")- # Try to encrypt, but fall back to plaintext if no encryption key+ # Try to encrypt, but fall back to storing plaintext if no encryption keytry:encrypted = CryptoUtils.encrypt(value)return cls.model_construct(encrypted_value=encrypted, was_encrypted=False)except ValueError as e:- # No encryption key available, store as plaintext+ # No encryption key available, store as plaintext in the _enc columnif "No encryption key configured" in str(e):logger.warning(- "No encryption key configured. Storing Secret value as plaintext. "+ "No encryption key configured. Storing Secret value as plaintext in _enc column. ""Set LETTA_ENCRYPTION_KEY environment variable to enable encryption.")instance = cls.model_construct(encrypted_value=value, was_encrypted=False)- instance._plaintext_cache = value # Cache it+ instance._plaintext_cache = value # Cache it since we know the plaintextreturn instanceraise # Re-raise if it's a different error@@ -81,25 +87,35 @@ class Secret(BaseModel):return cls.model_construct(encrypted_value=encrypted_value, was_encrypted=True)@classmethod- def from_db(cls, encrypted_value: Optional[str], plaintext_value: Optional[str]) -> "Secret":+ def from_db(cls, encrypted_value: Optional[str], plaintext_value: Optional[str] = None) -> "Secret":"""- Create a Secret from database values during migration phase.+ Create a Secret from database values. Prefers encrypted column, falls back to plaintext with error logging.++ During Phase 1 of migration, this method:+ 1. Uses encrypted_value if available (preferred)+ 2. Falls back to plaintext_value with ERROR logging if encrypted is unavailable+ 3. Returns empty Secret if neither is available- Prefers encrypted value if available, falls back to plaintext.+ The error logging helps identify any records that haven't been migrated to encrypted columns.Args:- encrypted_value: The encrypted value from the database- plaintext_value: The plaintext value from the database+ encrypted_value: The encrypted value from the database (_enc column)+ plaintext_value: The plaintext value from the database (legacy column, fallback only)Returns:- A Secret instance+ A Secret instance with the value from encrypted or plaintext column"""if encrypted_value is not None:return cls.from_encrypted(encrypted_value)- elif plaintext_value is not None:+ # Fallback to plaintext with error logging - this helps identify unmigrated data+ if plaintext_value is not None:+ logger.error(+ "MIGRATION_NEEDED: Reading from plaintext column instead of encrypted column. "+ "This indicates data that hasn't been migrated to the _enc column yet. "+ "Please run the backfill migration to populate _enc columns."+ )return cls.from_plaintext(plaintext_value)- else:- return cls.from_plaintext(None)+ return cls.from_plaintext(None)def get_encrypted(self) -> Optional[str]:"""@@ -117,23 +133,20 @@ class Secret(BaseModel):This should only be called when the plaintext is actually needed,such as when making an external API call.+ If the value is encrypted, it will be decrypted. If the value is stored+ as plaintext (no encryption key was configured), it will be returned as-is.+Returns:- The decrypted plaintext value+ The decrypted plaintext value, or None if the secret is empty"""if self.encrypted_value is None:return None- # Use cached value if available, but only if it looks like plaintext- # or we're confident we can decrypt it+ # Use cached value if availableif self._plaintext_cache is not None:- # If we have a cache but the stored value looks encrypted and we have no key,- # we should not use the cache- if CryptoUtils.is_encrypted(self.encrypted_value) and not CryptoUtils.is_encryption_available():- self._plaintext_cache = None # Clear invalid cache- else:- return self._plaintext_cache+ return self._plaintext_cache- # Decrypt and cache+ # Try to decrypttry:plaintext = CryptoUtils.decrypt(self.encrypted_value)# Cache the decrypted value (PrivateAttr fields can be mutated even with frozen=True)@@ -142,16 +155,14 @@ class Secret(BaseModel):except ValueError as e:error_msg = str(e)- # Handle missing encryption key+ # Handle missing encryption key - check if value is actually plaintextif "No encryption key configured" in error_msg:- # Check if the value looks encryptedif CryptoUtils.is_encrypted(self.encrypted_value):- # Value was encrypted, but now we have no key - can't decrypt+ # Value was encrypted but we have no key - can't decryptlogger.warning("Cannot decrypt Secret value - no encryption key configured. ""The value was encrypted and requires the original key to decrypt.")- # Return None to indicate we can't get the plaintextreturn Noneelse:# Value is plaintext (stored when no key was available)@@ -159,9 +170,8 @@ class Secret(BaseModel):self._plaintext_cache = self.encrypted_valuereturn self.encrypted_value- # Handle decryption failure (might be plaintext stored as such)+ # Handle decryption failure - check if value might be plaintextelif "Failed to decrypt data" in error_msg:- # Check if it might be plaintextif not CryptoUtils.is_encrypted(self.encrypted_value):# It's plaintext that was stored when no key was availablelogger.debug("Secret value appears to be plaintext (stored without encryption)")@@ -171,13 +181,6 @@ class Secret(BaseModel):logger.error("Failed to decrypt Secret value - data may be corrupted or wrong key")raise- # Migration case: handle legacy plaintext- elif not self.was_encrypted:- if self.encrypted_value and not CryptoUtils.is_encrypted(self.encrypted_value):- self._plaintext_cache = self.encrypted_value- return self.encrypted_value- return None-# Re-raise for other errorsraisediff --git a/letta/services/mcp_manager.py b/letta/services/mcp_manager.pyindex 8fa443c6d..b344ec3f4 100644--- a/letta/services/mcp_manager.py+++ b/letta/services/mcp_manager.py@@ -833,44 +833,26 @@ class MCPManager:def _oauth_orm_to_pydantic(self, oauth_session: MCPOAuth) -> MCPOAuthSession:"""Convert OAuth ORM model to Pydantic model, handling decryption of sensitive fields.++ Note: Prefers encrypted columns (_enc fields), falls back to plaintext with error logging.+ This helps identify unmigrated data during the migration period."""- # Get decrypted values using the dual-read approach- # Secret.from_db() will automatically use settings.encryption_key if available- access_token = None- if oauth_session.access_token_enc or oauth_session.access_token:- 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 available- access_token = oauth_session.access_token-- refresh_token = None- if oauth_session.refresh_token_enc or oauth_session.refresh_token:- 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 available- refresh_token = oauth_session.refresh_token-- client_secret = None- if oauth_session.client_secret_enc or oauth_session.client_secret:- 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 available- client_secret = oauth_session.client_secret-- authorization_code = None- if oauth_session.authorization_code_enc or oauth_session.authorization_code:- if settings.encryption_key:- secret = Secret.from_db(oauth_session.authorization_code_enc, oauth_session.authorization_code)- authorization_code = secret.get_plaintext()- else:- # No encryption key, use plaintext if available- authorization_code = oauth_session.authorization_code+ # Get decrypted values - prefer encrypted, fallback to plaintext with error logging+ access_token = Secret.from_db(+ encrypted_value=oauth_session.access_token_enc, plaintext_value=oauth_session.access_token+ ).get_plaintext()++ refresh_token = Secret.from_db(+ encrypted_value=oauth_session.refresh_token_enc, plaintext_value=oauth_session.refresh_token+ ).get_plaintext()++ client_secret = Secret.from_db(+ encrypted_value=oauth_session.client_secret_enc, plaintext_value=oauth_session.client_secret+ ).get_plaintext()++ authorization_code = Secret.from_db(+ encrypted_value=oauth_session.authorization_code_enc, plaintext_value=oauth_session.authorization_code+ ).get_plaintext()# Create the Pydantic object with encrypted fields as Secret objectspydantic_session = MCPOAuthSession(diff --git a/letta/services/mcp_server_manager.py b/letta/services/mcp_server_manager.pyindex 08639a130..36df93219 100644--- a/letta/services/mcp_server_manager.py+++ b/letta/services/mcp_server_manager.py@@ -988,44 +988,26 @@ class MCPServerManager:def _oauth_orm_to_pydantic(self, oauth_session: MCPOAuth) -> MCPOAuthSession:"""Convert OAuth ORM model to Pydantic model, handling decryption of sensitive fields.++ Note: Prefers encrypted columns (_enc fields), falls back to plaintext with error logging.+ This helps identify unmigrated data during the migration period."""- # Get decrypted values using the dual-read approach- # Secret.from_db() will automatically use settings.encryption_key if available- access_token = None- if oauth_session.access_token_enc or oauth_session.access_token:- 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 available- access_token = oauth_session.access_token-- refresh_token = None- if oauth_session.refresh_token_enc or oauth_session.refresh_token:- 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 available- refresh_token = oauth_session.refresh_token-- client_secret = None- if oauth_session.client_secret_enc or oauth_session.client_secret:- 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 available- client_secret = oauth_session.client_secret-- authorization_code = None- if oauth_session.authorization_code_enc or oauth_session.authorization_code:- if settings.encryption_key:- secret = Secret.from_db(oauth_session.authorization_code_enc, oauth_session.authorization_code)- authorization_code = secret.get_plaintext()- else:- # No encryption key, use plaintext if available- authorization_code = oauth_session.authorization_code+ # Get decrypted values - prefer encrypted, fallback to plaintext with error logging+ access_token = Secret.from_db(+ encrypted_value=oauth_session.access_token_enc, plaintext_value=oauth_session.access_token+ ).get_plaintext()++ refresh_token = Secret.from_db(+ encrypted_value=oauth_session.refresh_token_enc, plaintext_value=oauth_session.refresh_token+ ).get_plaintext()++ client_secret = Secret.from_db(+ encrypted_value=oauth_session.client_secret_enc, plaintext_value=oauth_session.client_secret+ ).get_plaintext()++ authorization_code = Secret.from_db(+ encrypted_value=oauth_session.authorization_code_enc, plaintext_value=oauth_session.authorization_code+ ).get_plaintext()# Create the Pydantic object with encrypted fields as Secret objectspydantic_session = MCPOAuthSession(diff --git a/tests/test_mcp_encryption.py b/tests/test_mcp_encryption.pyindex f5a5b989f..91dd77ebe 100644--- a/tests/test_mcp_encryption.py+++ b/tests/test_mcp_encryption.py@@ -192,38 +192,49 @@ class TestMCPServerEncryption:settings.encryption_key = original_key@pytest.mark.asyncio- @patch.dict(os.environ, {}, clear=True) # No encryption key@patch("letta.services.mcp_manager.MCPManager.get_mcp_client")- async def test_create_mcp_server_without_encryption_key(self, mock_get_client, server, default_user):- """Test that MCP servers work without encryption key (backward compatibility)."""- # Remove encryption key- os.environ.pop("LETTA_ENCRYPTION_KEY", None)+ async def test_create_mcp_server_without_encryption_key_stores_plaintext(self, mock_get_client, server, default_user):+ """Test that MCP servers work without encryption key by storing plaintext in _enc column.++ Note: In Phase 1 of migration, if no encryption key is configured, the value+ is stored as plaintext directly in the _enc column. This allows users without+ encryption keys to continue working while migrating off the old plaintext columns.+ """+ # Save and clear encryption key+ original_key = settings.encryption_key+ settings.encryption_key = None- # Mock the MCP client- mock_client = AsyncMock()- mock_client.list_tools.return_value = []- mock_get_client.return_value = mock_client+ try:+ # Mock the MCP client+ mock_client = AsyncMock()+ mock_client.list_tools.return_value = []+ mock_get_client.return_value = mock_client- server_name = f"test_no_encrypt_server_{uuid4().hex[:8]}"- token = "plaintext-token-no-encryption"+ server_name = f"test_no_encrypt_server_{uuid4().hex[:8]}"+ token = "plaintext-token-no-encryption"- mcp_server = PydanticMCPServer(- server_name=server_name, server_type=MCPServerType.SSE, server_url="https://api.example.com", token=token- )+ mcp_server = PydanticMCPServer(+ server_name=server_name, server_type=MCPServerType.SSE, server_url="https://api.example.com", token=token+ )- created_server = await server.mcp_manager.create_or_update_mcp_server(mcp_server, actor=default_user)+ # Should work without encryption key - stores plaintext in _enc column+ created_server = await server.mcp_manager.create_or_update_mcp_server(mcp_server, actor=default_user)- # Check database - should store as plaintext- 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 - should store plaintext in _enc column+ 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()- # Should store in plaintext column- assert db_server.token == token- assert db_server.token_enc is None # No encryption+ # Token should be stored as plaintext in _enc column (not encrypted)+ assert db_server.token_enc == token # Plaintext stored directly+ # Legacy plaintext column should also be populated (dual-write)+ assert db_server.token == token- # 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_keyclass TestMCPOAuthEncryption:@@ -408,8 +419,13 @@ class TestMCPOAuthEncryption:settings.encryption_key = original_key@pytest.mark.asyncio- async def test_dual_read_backward_compatibility(self, server, default_user):- """Test that system can read both encrypted and plaintext values (migration support)."""+ async def test_encrypted_only_reads(self, server, default_user):+ """Test that system only reads from encrypted columns, ignoring plaintext.++ Note: In Phase 1 of migration, reads are encrypted-only. Plaintext columns+ are ignored even if they contain values. This test verifies that the+ encrypted value is used and plaintext is never used as fallback.+ """# Set encryption key directly on settingsoriginal_key = settings.encryption_keysettings.encryption_key = self.MOCK_ENCRYPTION_KEY@@ -426,10 +442,10 @@ class TestMCPOAuthEncryption:id=session_id,state=f"dual-read-state-{uuid4().hex[:8]}",server_url="https://test.com/mcp",- server_name="Dual Read Test",+ server_name="Encrypted Only Read Test",# Both encrypted and plaintext values- access_token=plaintext_token, # Legacy plaintext- access_token_enc=encrypted_new, # New encrypted+ access_token=plaintext_token, # Legacy plaintext - should be ignored+ access_token_enc=encrypted_new, # Encrypted value - should be usedclient_id="test-client",user_id=default_user.id,organization_id=default_user.organization_id,@@ -443,7 +459,7 @@ class TestMCPOAuthEncryption: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+ # Should use encrypted value only (plaintext is ignored)assert test_session.access_token == new_encrypted_token# Clean up not needed - test database is reset@@ -451,3 +467,58 @@ class TestMCPOAuthEncryption:finally:# Restore original encryption keysettings.encryption_key = original_key++ @pytest.mark.asyncio+ async def test_plaintext_only_record_fallback_with_error_logging(self, server, default_user, caplog):+ """Test that records with only plaintext values fall back to plaintext with error logging.++ Note: In Phase 1 of migration, if a record only has plaintext value+ (no encrypted value), the system falls back to plaintext but logs an error+ to help identify unmigrated data.+ """+ import logging++ # Set encryption key directly on settings+ original_key = settings.encryption_key+ settings.encryption_key = self.MOCK_ENCRYPTION_KEY++ try:+ # Insert a record with only plaintext value (no encrypted)+ session_id = f"mcp-oauth-{str(uuid4())[:8]}"+ plaintext_token = "legacy-plaintext-token"++ async with db_registry.async_session() as session:+ db_oauth = MCPOAuth(+ id=session_id,+ state=f"plaintext-only-state-{uuid4().hex[:8]}",+ server_url="https://test.com/mcp",+ server_name="Plaintext Only Test",+ # Only plaintext value, no encrypted+ access_token=plaintext_token, # Legacy plaintext - should fallback with error log+ access_token_enc=None, # No encrypted value+ 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 - should log error about plaintext fallback+ with caplog.at_level(logging.ERROR):+ test_session = await server.mcp_manager.get_oauth_session_by_id(session_id, actor=default_user)++ assert test_session is not None++ # Should fall back to plaintext value+ assert test_session.access_token == plaintext_token++ # Should have logged an error about reading from plaintext column+ assert "MIGRATION_NEEDED" in caplog.text++ # 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 b4151875d..af6e9a47e 100644--- a/tests/test_secret.py+++ b/tests/test_secret.py@@ -35,8 +35,8 @@ class TestSecret:finally:settings.encryption_key = original_key- def test_from_plaintext_without_key(self):- """Test creating a Secret from plaintext without encryption key (fallback behavior)."""+ def test_from_plaintext_without_key_stores_plaintext(self):+ """Test creating a Secret from plaintext without encryption key stores as plaintext."""from letta.settings import settings# Clear encryption key@@ -46,10 +46,10 @@ class TestSecret:try:plaintext = "my-plaintext-value"- # Should now handle gracefully and store as plaintext+ # Should store as plaintext in _enc column when no encryption keysecret = Secret.from_plaintext(plaintext)- # Should store the plaintext value+ # Should store the plaintext value directly in encrypted_valueassert secret.encrypted_value == plaintextassert secret.get_plaintext() == plaintextassert not secret.was_encrypted@@ -103,8 +103,14 @@ class TestSecret:finally:settings.encryption_key = original_key- def test_from_db_with_plaintext_value(self):- """Test creating a Secret from database with plaintext value (backward compatibility)."""+ def test_from_db_with_plaintext_value_fallback(self, caplog):+ """Test creating a Secret from database with only plaintext value falls back with error logging.++ Note: In Phase 1 of migration, from_db() prefers encrypted but falls back to plaintext+ with error logging to help identify unmigrated data.+ """+ import logging+from letta.settings import settingsoriginal_key = settings.encryption_key@@ -113,13 +119,16 @@ class TestSecret:try:plaintext = "legacy-plaintext"- # When only plaintext is provided, should encrypt it- secret = Secret.from_db(encrypted_value=None, plaintext_value=plaintext)+ # When only plaintext is provided, should fall back to plaintext with error logging+ with caplog.at_level(logging.ERROR):+ secret = Secret.from_db(encrypted_value=None, plaintext_value=plaintext)- # Should encrypt the plaintext- assert secret.encrypted_value is not None- assert secret.was_encrypted is False+ # Should use the plaintext value (fallback)assert secret.get_plaintext() == plaintext++ # Should have logged an error about reading from plaintext column+ assert "MIGRATION_NEEDED" in caplog.text+ assert "plaintext column" in caplog.textfinally:settings.encryption_key = original_key