debug2

app.py

@@ -17,7 +17,7 @@ from slack_bolt.oauth.async_oauth_settings import AsyncOAuthSettings
 from slack_sdk.oauth.installation_store.async_installation_store import AsyncInstallationStore
 from slack_sdk.oauth import AuthorizeUrlGenerator
 from slack_sdk.oauth.installation_store.models import Installation
-from slack_bolt.authorization import AuthorizeResult  # Fixed: Use AuthorizeResult instead of AsyncAuthorizeResult
+from slack_bolt.authorization import AuthorizeResult
 
 # RAG/ML Libraries
 from sentence_transformers import SentenceTransformer
@@ -32,8 +32,6 @@ from docx import Document
 import requests
 
 # --- Configuration and Initialization ---
-
-# Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
@@ -56,7 +54,7 @@ if not all(required_vars):
 if not SLACK_BOT_TOKEN:
     raise ValueError("SLACK_BOT_TOKEN is required for single-team mode.")
 
-# Set HF_TOKEN if provided (helps with authentication for Hub access)
+# Set HF_TOKEN if provided
 if HF_TOKEN:
     try:
         login(token=HF_TOKEN, add_to_git_credential=False)
@@ -67,7 +65,7 @@ if HF_TOKEN:
 # Initialize Supabase client
 supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
 
-# --- Supabase Async Installation Store (for multi-team; optional) ---
+# --- Supabase Async Installation Store ---
 class SupabaseAsyncInstallationStore(AsyncInstallationStore):
     def __init__(self, supabase_client):
         self.supabase = supabase_client
@@ -125,67 +123,84 @@ class SupabaseAsyncInstallationStore(AsyncInstallationStore):
             logger.error(f"Failed to delete installation for team {team_id}: {e}")
             raise
 
-# Initialize installation store (only if multi-team)
+# Initialize installation store
 installation_store = None
-USE_MULTI_TEAM = os.environ.get("USE_MULTI_TEAM", "false").lower() == "true"  # Set env to 'true' for multi-team
+USE_MULTI_TEAM = os.environ.get("USE_MULTI_TEAM", "false").lower() == "true"
+
 if USE_MULTI_TEAM:
     installation_store = SupabaseAsyncInstallationStore(supabase)
     logger.info("Using multi-team mode with Supabase store.")
 else:
     logger.info("Using single-team mode with SLACK_BOT_TOKEN.")
 
-# Custom authorize for multi-team (falls back to store)
+# FIXED: Custom authorize function that works for both single and multi-team
 async def async_authorize(enterprise_id, team_id, user_id):
+    """
+    Custom authorization function.
+    For single-team: Returns a static AuthorizeResult using SLACK_BOT_TOKEN.
+    For multi-team: Fetches from installation store.
+    """
     logger.info(f"Custom authorize called for enterprise: {enterprise_id}, team: {team_id}, user: {user_id}")
+    
     if not USE_MULTI_TEAM:
-        return None  # Single-team doesn't need this
+        # FIXED: Return AuthorizeResult for single-team mode instead of None
+        logger.info("Single-team mode: Using SLACK_BOT_TOKEN")
+        return AuthorizeResult(
+            enterprise_id=enterprise_id,
+            team_id=team_id,
+            bot_user_id=None,  # Will be populated automatically by Slack SDK
+            bot_token=SLACK_BOT_TOKEN,
+            user_id=user_id,
+        )
+    
+    # Multi-team mode: fetch from store
     installation = await installation_store.fetch_installation(team_id=team_id, enterprise_id=enterprise_id)
     if installation:
-        return AuthorizeResult(  # Fixed: Use AuthorizeResult
+        return AuthorizeResult(
             enterprise_id=enterprise_id or installation.enterprise_id,
             team_id=team_id,
             user_id=user_id or installation.user_id,
             bot_token=installation.bot_token,
             bot_user_id=installation.bot_user_id,
         )
+    
     logger.error(f"No authorization found for team {team_id}")
     return None
 
-# Initialize Bolt Async App
+# FIXED: Initialize Bolt Async App with proper configuration
 app = AsyncApp(
     signing_secret=SLACK_SIGNING_SECRET,
-    token=SLACK_BOT_TOKEN if not USE_MULTI_TEAM else None,  # Single-team: use token
-    installation_store=installation_store,
-    authorize=async_authorize if USE_MULTI_TEAM else None,  # Multi-team: custom authorize
+    token=None,  # Always use None when using authorize function
+    installation_store=installation_store if USE_MULTI_TEAM else None,
+    authorize=async_authorize,  # Always use custom authorize
     oauth_settings=AsyncOAuthSettings(
         client_id=SLACK_CLIENT_ID,
         client_secret=SLACK_CLIENT_SECRET,
         scopes=["app_mentions:read", "files:read", "chat:write", "im:read", "im:write", "channels:read"],
         redirect_uri_path="/slack/oauth/callback",
-    ),
+    ) if USE_MULTI_TEAM else None,
 )
 
 api = FastAPI()
 
 # --- RAG Model Loading ---
-# Check for GPU and set device
 device = 'cuda' if torch.cuda.is_available() else 'cpu'
 logger.info(f"Using device: {device}")
 
 print("Loading embedding model...")
 embedding_model = None
 qa_pipeline = None
+
 try:
     embedding_model = SentenceTransformer('all-MiniLM-L6-v2', device=device)
     print("Loading QA model...")
-    qa_pipeline = pipeline("question-answering", model="deepset/roberta-base-squad2", device=device)
+    qa_pipeline = pipeline("question-answering", model="deepset/roberta-base-squad2", device=0 if device == 'cuda' else -1)
     print("Models loaded successfully!")
 except Exception as e:
     logger.error(f"Error loading models: {e}")
     raise RuntimeError("Failed to load required ML models. Check dependencies and hardware.")
 
 # --- Utility Functions ---
-
 def download_slack_file(url: str, token: str) -> bytes:
     """Downloads a file from Slack using the private download URL and bot token."""
     try:
@@ -289,7 +304,7 @@ async def answer_question(question: str, context: str) -> str:
     if not context.strip():
         return "No relevant documents found."
     try:
-        MAX_CONTEXT_LEN = 4096 
+        MAX_CONTEXT_LEN = 4096
         context_slice = context[:MAX_CONTEXT_LEN]
         
         result = await asyncio.to_thread(
@@ -301,7 +316,6 @@ async def answer_question(question: str, context: str) -> str:
         return "Error generating answer from context."
 
 # --- Slack Handlers (Async) ---
-
 @app.event("file_shared")
 async def handle_file_shared(event, say, client):
     """Processes files shared in a channel and adds their content to the RAG knowledge base."""
@@ -317,7 +331,7 @@ async def handle_file_shared(event, say, client):
             await say("No download URL available for the file.")
             return
         
-        token = client.token 
+        token = client.token
         file_content = await asyncio.to_thread(download_slack_file, file_url, token)
         
         text = ""
@@ -347,23 +361,11 @@ async def handle_mention(event, say, client):
     text = event["text"]
     user_query = re.sub(r'<@[A-Z0-9]+>', '', text).strip()
     
-    # Simple check for the presence of a file in the message for combined upload/query
-    files = event.get("files", [])
-    if files:
-        await say("I see a file attached. I'll process it first, and then answer your question.")
-        # NOTE: Handling files in app_mention is complex due to timing/race conditions. 
-        # For simplicity, we delegate file processing primarily to file_shared event.
-        # This loop is kept as a fallback/redundancy but the file_shared event is more reliable.
-        # The logic here is *identical* to file_shared and is omitted for brevity but should
-        # be included if you expect users to combine uploads and queries in one message.
-        pass # The file processing logic from the original code would go here
-    
     if not user_query:
         await say("Please ask me a question after mentioning me!")
         return
     
     try:
-        # Check if table is empty
         if await is_table_empty():
             await say("My knowledge base is empty. Please share some PDF or DOCX files first so I can learn!")
             return
@@ -374,19 +376,15 @@ async def handle_mention(event, say, client):
             await say("I couldn't find any relevant information in my knowledge base. Try uploading more documents.")
             return
         
-        # Combine the content of the top documents into a single context string
         context = " ".join([doc["content"] for doc in results])
         answer = await answer_question(user_query, context)
         
-        # Format the final response
         await say(f"💡 *Answer:* {answer}\n\n_I found this information by analyzing {len(results)} relevant document chunks._")
     except Exception as e:
         logger.error(f"Error in app_mention handler for query '{user_query}': {str(e)}")
         await say(f"❌ Error answering question: {str(e)}")
 
 # --- FastAPI Integration ---
-
-# Initialize the Async Slack Request Handler
 handler = AsyncSlackRequestHandler(app)
 
 @api.post("/slack/events")
@@ -410,14 +408,19 @@ async def health():
     db_status = "error"
     try:
         await asyncio.to_thread(
-            lambda: supabase.table("installations").select("team_id").limit(1).execute()
+            lambda: supabase.table("documents").select("id").limit(1).execute()
         )
         db_status = "ok"
     except Exception as e:
         logger.error(f"Database health check failed: {e}")
     
     models_status = "ok" if embedding_model and qa_pipeline else "error"
-    return {"status": "ok" if db_status == "ok" and models_status == "ok" else "error", "database": db_status, "models": models_status}
+    return {
+        "status": "ok" if db_status == "ok" and models_status == "ok" else "error",
+        "database": db_status,
+        "models": models_status,
+        "mode": "single-team" if not USE_MULTI_TEAM else "multi-team"
+    }
 
 @api.get("/slack/install")
 async def install_url():
@@ -440,36 +443,48 @@ async def oauth_callback(request: Request):
     try:
         logger.info("OAuth callback received")
         response = await handler.handle(request)
-        logger.info(f"OAuth callback response: {response.status_code if hasattr(response, 'status_code') else 'No status'}")
+        logger.info(f"OAuth callback handled")
+        
         if hasattr(response, 'status_code') and response.status_code == 200:
-            # In single-team, no need to save; for multi, it should auto-save via store
-            if USE_MULTI_TEAM:
-                logger.info("Multi-team install: Check Supabase for new data.")
             return HTMLResponse(
-                content=f"<html><body><h1>Installation successful!</h1><p>You can now use the bot in your Slack workspace.</p><p>Mode: {'Single-team (no store needed)' if not USE_MULTI_TEAM else 'Multi-team (check Supabase)'}</p><p><a href='/debug/installations'>Debug Installations</a></p></body></html>",
+                content=f"""<html>
+                <body>
+                    <h1>Installation successful!</h1>
+                    <p>You can now use the bot in your Slack workspace.</p>
+                    <p>Mode: {'Single-team' if not USE_MULTI_TEAM else 'Multi-team'}</p>
+                </body>
+                </html>""",
                 status_code=200
             )
         return response
     except Exception as e:
         logger.error(f"OAuth Callback Error: {e}")
         return HTMLResponse(
-            content=f"<html><body><h1>Installation Failed!</h1><p>Error: {str(e)}</p><p>Check logs. If multi-team, ensure Supabase table exists.</p></body></html>",
+            content=f"""<html>
+            <body>
+                <h1>Installation Failed!</h1>
+                <p>Error: {str(e)}</p>
+                <p>Check logs for details.</p>
+            </body>
+            </html>""",
             status_code=500
         )
 
-# Optional: Add a debug endpoint to check installation
 @api.get("/debug/installations")
 async def debug_installations():
-    """Debug: List all installations (remove in prod)."""
+    """Debug: List all installations (remove in production)."""
     try:
         result = await asyncio.to_thread(
             lambda: supabase.table("installations").select("*").execute()
         )
-        return {"installations": result.data, "mode": "multi-team" if USE_MULTI_TEAM else "single-team"}
+        return {
+            "installations": result.data,
+            "mode": "multi-team" if USE_MULTI_TEAM else "single-team",
+            "count": len(result.data)
+        }
     except Exception as e:
         return {"error": str(e)}
 
-
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
     uvicorn_run(api, host="0.0.0.0", port=port)