Fix type errors and test failures

- Fix OAuthClientInformationFull initialization with empty defaults
- Fix TokenError and AuthorizeError to use literal strings instead of enums
- Fix token_type to use lowercase 'bearer' as required by OAuthToken
- Fix potentially None values in _generate_mcp_token calls
- Fix ProjectService repository.update calls to include entity_id
- Fix prompt_router.py to handle undefined variables
- Fix config.py field_validator return type
- Fix external_auth_provider.py to add state field
- Fix supabase_auth_provider.py redirect_uris parameter
- Make Importer.handle_error abstract to fix test failures
- Remove unused imports

All type checks now pass and all tests are green.

Author: phernandez

src/basic_memory/api/routers/prompt_router.py

@@ -53,6 +53,9 @@ async def continue_conversation(
 
     since = parse(request.timeframe) if request.timeframe else None
 
+    # Initialize search results
+    search_results = []
+
     # Get data needed for template
     if request.topic:
         query = SearchQuery(text=request.topic, after_date=request.timeframe)
@@ -122,9 +125,12 @@ async def continue_conversation(
         relation_count = 0
         entity_count = 0
 
+        # Get the hierarchical results from the template context
+        hierarchical_results_for_count = template_context.get("hierarchical_results", [])
+
         # For topic-based search
         if request.topic:
-            for item in all_hierarchical_results:
+            for item in hierarchical_results_for_count:
                 if hasattr(item, "observations"):
                     observation_count += len(item.observations) if item.observations else 0
 
@@ -137,7 +143,7 @@ async def continue_conversation(
                                 entity_count += 1  # pragma: no cover
         # For recent activity
         else:
-            for item in hierarchical_results:
+            for item in hierarchical_results_for_count:
                 if hasattr(item, "observations"):
                     observation_count += len(item.observations) if item.observations else 0
 
@@ -153,14 +159,14 @@ async def continue_conversation(
         metadata = {
             "query": request.topic,
             "timeframe": request.timeframe,
-            "search_count": len(results) if request.topic else 0,  # Original search results count
-            "context_count": len(all_hierarchical_results)
+            "search_count": len(search_results)
             if request.topic
-            else len(hierarchical_results),
+            else 0,  # Original search results count
+            "context_count": len(hierarchical_results_for_count),
             "observation_count": observation_count,
             "relation_count": relation_count,
             "total_items": (
-                len(all_hierarchical_results if request.topic else hierarchical_results)
+                len(hierarchical_results_for_count)
                 + observation_count
                 + relation_count
                 + entity_count

src/basic_memory/cli/commands/auth.py

@@ -12,6 +12,7 @@
 auth_app = typer.Typer(help="OAuth client management commands")
 app.add_typer(auth_app, name="auth")
 
+
 @auth_app.command()
 def register_client(
     client_id: Optional[str] = typer.Option(
@@ -27,12 +28,10 @@ def register_client(
     # Create provider instance
     provider = BasicMemoryOAuthProvider(issuer_url=issuer_url)
 
-
-    
     # Create client info with required redirect_uris
     client_info = OAuthClientInformationFull(
-        client_id=client_id,
-        client_secret=client_secret,
+        client_id=client_id or "",  # Provider will generate if empty
+        client_secret=client_secret or "",  # Provider will generate if empty
         redirect_uris=[AnyHttpUrl("http://localhost:8000/callback")],  # Default redirect URI
         client_name="Basic Memory OAuth Client",
         grant_types=["authorization_code", "refresh_token"],

src/basic_memory/cli/commands/db.py

@@ -7,7 +7,7 @@
 
 from basic_memory import db
 from basic_memory.cli.app import app
-from basic_memory.config import config
+from basic_memory.config import app_config
 
 
 @app.command()
@@ -18,15 +18,15 @@ def reset(
     if typer.confirm("This will delete all data in your db. Are you sure?"):
         logger.info("Resetting database...")
         # Get database path
-        db_path = config.database_path
+        db_path = app_config.app_database_path
 
         # Delete the database file if it exists
         if db_path.exists():
             db_path.unlink()
             logger.info(f"Database file deleted: {db_path}")
 
         # Create a new empty database
-        asyncio.run(db.run_migrations(config))
+        asyncio.run(db.run_migrations(app_config))
         logger.info("Database reset complete")
 
         if reindex:

src/basic_memory/config.py

@@ -129,7 +129,7 @@ def project_list(self) -> List[ProjectConfig]:  # pragma: no cover
 
     @field_validator("projects")
     @classmethod
-    def ensure_project_paths_exists(cls, v: Dict[str, str]) -> Path:  # pragma: no cover
+    def ensure_project_paths_exists(cls, v: Dict[str, str]) -> Dict[str, str]:  # pragma: no cover
         """Ensure project path exists."""
         for name, path_value in v.items():
             path = Path(path_value)

src/basic_memory/importers/base.py

@@ -63,6 +63,7 @@ def ensure_folder_exists(self, folder: str) -> Path:
         folder_path.mkdir(parents=True, exist_ok=True)
         return folder_path
 
+    @abstractmethod
     def handle_error(
         self, message: str, error: Optional[Exception] = None
     ) -> T:  # pragma: no cover
@@ -75,13 +76,4 @@ def handle_error(
         Returns:
             ImportResult with error information.
         """
-        error_message = f"{message}"
-        if error:
-            error_message += f": {str(error)}"
-
-        logger.error(error_message)
-        return ImportResult(
-            import_count={},
-            success=False,
-            error_message=error_message,
-        )
+        pass

src/basic_memory/mcp/external_auth_provider.py

@@ -22,6 +22,7 @@ class ExternalAuthorizationCode(AuthorizationCode):
     """Authorization code with external provider metadata."""
 
     external_code: Optional[str] = None
+    state: Optional[str] = None
 
 
 @dataclass
@@ -103,6 +104,7 @@ async def authorize(
             code_challenge=params.code_challenge,
             redirect_uri=params.redirect_uri,
             redirect_uri_provided_explicitly=params.redirect_uri_provided_explicitly,
+            state=params.state,
         )
 
         # Build external provider URL
@@ -153,6 +155,7 @@ async def handle_callback(self, code: str, state: str) -> str:
             redirect_uri=auth_code.redirect_uri,
             redirect_uri_provided_explicitly=auth_code.redirect_uri_provided_explicitly,
             external_code=code,
+            state=auth_code.state,
         )
 
         self.tokens[internal_code] = external_tokens
@@ -161,7 +164,7 @@ async def handle_callback(self, code: str, state: str) -> str:
         return construct_redirect_uri(
             str(auth_code.redirect_uri),
             code=internal_code,
-            state=auth_code.issuer_state,
+            state=auth_code.state,
         )
 
     async def load_authorization_code(
@@ -206,7 +209,7 @@ async def exchange_authorization_code(
 
         return OAuthToken(
             access_token=access_token,
-            token_type="Bearer",
+            token_type="bearer",
             expires_in=expires_in,
             refresh_token=refresh_token,
             scope=" ".join(authorization_code.scopes) if authorization_code.scopes else None,
@@ -269,7 +272,7 @@ async def exchange_refresh_token(
 
         return OAuthToken(
             access_token=new_access_token,
-            token_type="Bearer",
+            token_type="bearer",
             expires_in=expires_in,
             refresh_token=new_refresh_token,
             scope=" ".join(scopes or refresh_token.scopes),

src/basic_memory/mcp/server.py

@@ -53,12 +53,12 @@ def create_auth_config() -> tuple[AuthSettings | None, Any | None]:
 
     if os.getenv("FASTMCP_AUTH_ENABLED", "false").lower() == "true":
         from pydantic import AnyHttpUrl
-        
+
         # Configure OAuth settings
         issuer_url = os.getenv("FASTMCP_AUTH_ISSUER_URL", "http://localhost:8000")
         required_scopes = os.getenv("FASTMCP_AUTH_REQUIRED_SCOPES", "read,write")
         docs_url = os.getenv("FASTMCP_AUTH_DOCS_URL") or "http://localhost:8000/docs/oauth"
-        
+
         auth_settings = AuthSettings(
             issuer_url=AnyHttpUrl(issuer_url),
             service_documentation_url=AnyHttpUrl(docs_url),

src/basic_memory/mcp/supabase_auth_provider.py

@@ -16,9 +16,7 @@
     RefreshToken,
     AccessToken,
     TokenError,
-    TokenErrorCode,
     AuthorizeError,
-    AuthorizationErrorCode,
 )
 from mcp.shared.auth import OAuthClientInformationFull, OAuthToken
 
@@ -91,6 +89,7 @@ async def get_client(self, client_id: str) -> Optional[OAuthClientInformationFul
             return OAuthClientInformationFull(
                 client_id=client_id,
                 client_secret="",  # Supabase handles secrets
+                redirect_uris=[],  # Supabase handles redirect URIs
             )
 
         return None
@@ -150,7 +149,7 @@ async def handle_supabase_callback(self, code: str, state: str) -> str:
         auth_request = self.pending_auth_codes.get(state)
         if not auth_request:
             raise AuthorizeError(
-                error=AuthorizationErrorCode.INVALID_REQUEST,
+                error="invalid_request",
                 error_description="Invalid state parameter",
             )
 
@@ -170,7 +169,7 @@ async def handle_supabase_callback(self, code: str, state: str) -> str:
 
         if not token_response.is_success:
             raise AuthorizeError(
-                error=AuthorizationErrorCode.SERVER_ERROR,
+                error="server_error",
                 error_description="Failed to exchange code with Supabase",
             )
 
@@ -233,18 +232,16 @@ async def exchange_authorization_code(
         # Get stored Supabase tokens
         token_data = self.mcp_to_supabase_tokens.get(authorization_code.code)
         if not token_data:
-            raise TokenError(
-                error=TokenErrorCode.INVALID_GRANT, error_description="Invalid authorization code"
-            )
+            raise TokenError(error="invalid_grant", error_description="Invalid authorization code")
 
         supabase_tokens = token_data["supabase_tokens"]
         user = token_data["user"]
 
         # Generate MCP tokens that wrap Supabase tokens
         access_token = self._generate_mcp_token(
             client_id=client.client_id,
-            user_id=user.get("id"),
-            email=user.get("email"),
+            user_id=user.get("id", ""),
+            email=user.get("email", ""),
             scopes=authorization_code.scopes,
             supabase_access_token=supabase_tokens["access_token"],
         )
@@ -275,7 +272,7 @@ async def exchange_authorization_code(
 
         return OAuthToken(
             access_token=access_token,
-            token_type="Bearer",
+            token_type="bearer",
             expires_in=supabase_tokens.get("expires_in", 3600),
             refresh_token=refresh_token,
             scope=" ".join(authorization_code.scopes) if authorization_code.scopes else None,
@@ -320,7 +317,7 @@ async def exchange_refresh_token(
 
         if not token_response.is_success:
             raise TokenError(
-                error=TokenErrorCode.INVALID_GRANT,
+                error="invalid_grant",
                 error_description="Failed to refresh with Supabase",
             )
 
@@ -340,8 +337,8 @@ async def exchange_refresh_token(
         # Generate new MCP tokens
         new_access_token = self._generate_mcp_token(
             client_id=client.client_id,
-            user_id=user_data.get("id"),
-            email=user_data.get("email"),
+            user_id=user_data.get("id", ""),
+            email=user_data.get("email", ""),
             scopes=scopes or refresh_token.scopes,
             supabase_access_token=supabase_tokens["access_token"],
         )
@@ -370,7 +367,7 @@ async def exchange_refresh_token(
 
         return OAuthToken(
             access_token=new_access_token,
-            token_type="Bearer",
+            token_type="bearer",
             expires_in=supabase_tokens.get("expires_in", 3600),
             refresh_token=new_refresh_token,
             scope=" ".join(scopes or refresh_token.scopes),

src/basic_memory/services/project_service.py

@@ -225,14 +225,14 @@ async def update_project(  # pragma: no cover
 
             # Update in database
             project.path = resolved_path
-            await self.repository.update(project)
+            await self.repository.update(project.id, project)
 
             logger.info(f"Updated path for project '{name}' to {resolved_path}")
 
         # Update active status if provided
         if is_active is not None:
             project.is_active = is_active
-            await self.repository.update(project)
+            await self.repository.update(project.id, project)
             logger.info(f"Set active status for project '{name}' to {is_active}")
 
         # If project was made inactive and it was the default, we need to pick a new default

tests/importers/test_importer_base.py

@@ -26,6 +26,23 @@ async def import_data(self, source_data, destination_folder: str, **kwargs):
         except Exception as e:
             return self.handle_error("Test import failed", e)
 
+    def handle_error(self, message: str, error=None) -> ImportResult:
+        """Implement the abstract handle_error method."""
+        import logging
+
+        logger = logging.getLogger(__name__)
+
+        error_message = f"{message}"
+        if error:
+            error_message += f": {str(error)}"
+
+        logger.error(error_message)
+        return ImportResult(
+            import_count={},
+            success=False,
+            error_message=error_message,
+        )
+
 
 @pytest.fixture
 def mock_markdown_processor():