Upload 9 files

main.py

@@ -34,7 +34,17 @@ if sys.platform == "win32":
     logging.info("Set WindowsProactorEventLoopPolicy for asyncio.")
 
 # --- Logging Configuration ---
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+# Change logging level from INFO to WARNING to reduce verbosity
+# Only important messages and errors will be displayed
+logging.basicConfig(
+    level=logging.WARNING,  # Changed from INFO to WARNING
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'  # Standardize date format
+)
+
+# Create a custom logger for critical account operations that we always want to see
+account_logger = logging.getLogger("notion_account")
+account_logger.setLevel(logging.INFO)
 
 # --- Account Management Class ---
 class NotionAccount:
@@ -86,11 +96,7 @@ def authenticate(credentials: HTTPAuthorizationCredentials = Depends(security)):
 # --- Notion Account Management ---
 
 def get_next_account() -> NotionAccount:
-    """
-    Selects the next healthy Notion account using a round-robin strategy.
-    This function is not async and relies on Python's GIL for atomic index updates,
-    which is safe in a single-threaded asyncio environment.
-    """
+    """Selects the next healthy Notion account using a round-robin strategy."""
     global CURRENT_ACCOUNT_INDEX
     
     # This check runs on every request to ensure we don't try to select from an empty list
@@ -108,38 +114,29 @@ def get_next_account() -> NotionAccount:
             detail="No healthy Notion accounts available to process the request."
         )
 
-    # Round-robin logic: iterate through all accounts to find the next healthy one
-    # This ensures that we can recover if an account becomes healthy again later.
-    # A lock is not strictly necessary in asyncio for a simple index increment,
-    # but could be added for thread-safety if using a threaded server.
+    # Round-robin logic
     start_index = CURRENT_ACCOUNT_INDEX
     while True:
         account = ACCOUNTS[CURRENT_ACCOUNT_INDEX]
         CURRENT_ACCOUNT_INDEX = (CURRENT_ACCOUNT_INDEX + 1) % len(ACCOUNTS)
         if account.is_healthy:
-            logging.info(f"Selected Notion account: {account.user_email} (User ID: {account.user_id}) for request.")
+            account_logger.warning(f"Using account: {account.user_email}")
             return account
-        # This check prevents an infinite loop if no accounts are healthy,
-        # although the initial check for healthy_accounts should prevent this.
         if CURRENT_ACCOUNT_INDEX == start_index:
-            # This part should theoretically not be reached.
             raise HTTPException(
                 status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
                 detail="Critical error in account selection: No healthy accounts found in rotation."
             )
 
-# --- FastAPI App ---
-
 async def fetch_and_set_notion_ids(account: NotionAccount):
     """Fetches space ID and user ID for a given Notion account and marks it as healthy on success."""
     async with account.lock: # Ensure only one fetch operation per account at a time
         if account.is_healthy: # Don't re-fetch if already healthy
-             logging.info(f"Account for user {account.user_id} is already healthy, skipping fetch.")
              return
 
     if not account.cookie:
-        logging.error("Cannot fetch Notion IDs: Account cookie is not set.")
-        logging.error(f"Failing cookie (empty): {account.cookie}")
+        account_logger.error("Account validation failed: Cookie not set")
+        account_logger.error(f"Failing cookie (empty): {account.cookie}")
         account.is_healthy = False
         return
 
@@ -150,10 +147,10 @@ async def fetch_and_set_notion_ids(account: NotionAccount):
         'accept': '*/*',
         'accept-language': 'en-US,en;q=0.9',
         'notion-audit-log-platform': 'web',
-        'notion-client-version': '23.13.0.3686', # Match cURL example or use a recent one
+        'notion-client-version': '23.13.0.3686',
         'origin': 'https://www.notion.so',
         'priority': 'u=1, i',
-        'referer': 'https://www.notion.so/', # Simplified
+        'referer': 'https://www.notion.so/',
         'sec-ch-ua': '"Chromium";v="136", "Google Chrome";v="136", "Not.A/Brand";v="99"',
         'sec-ch-ua-mobile': '?0',
         'sec-ch-ua-platform': '"Windows"',
@@ -168,7 +165,6 @@ async def fetch_and_set_notion_ids(account: NotionAccount):
     page = None
 
     try:
-        logging.info(f"Attempting to fetch Notion user/space IDs for an account...")
         async with async_playwright() as p:
             # Configure browser launch with proxy if PROXY_URL is set
             launch_args = {
@@ -177,17 +173,8 @@ async def fetch_and_set_notion_ids(account: NotionAccount):
             }
             if PROXY_URL:
                 launch_args['proxy'] = {'server': PROXY_URL}
-                logging.info(f"Using proxy for browser launch: {PROXY_URL}")
-            
-            try:
-                browser = await p.chromium.launch(**launch_args)
-            except PlaywrightError as e:
-                if PROXY_URL and "proxy" in str(e).lower():
-                    logging.error(f"Invalid proxy URL or proxy connection failed: {PROXY_URL}. Error: {e}")
-                    raise PlaywrightError(f"Proxy configuration error: {e}")
-                else:
-                    raise
             
+            browser = await p.chromium.launch(**launch_args)
             context = await browser.new_context(user_agent=js_fetch_headers['user-agent'])
 
             # Add cookies from the account's cookie string
@@ -204,18 +191,13 @@ async def fetch_and_set_notion_ids(account: NotionAccount):
             if cookies_to_add:
                 await context.add_cookies(cookies_to_add)
             else:
-                logging.error("No valid cookies parsed from account's cookie for getSpaces.")
-                logging.error(f"Failing cookie: {account.cookie}")
+                account_logger.error("Account validation failed: No valid cookies parsed")
+                account_logger.error(f"Failing cookie: {account.cookie}")
                 account.is_healthy = False
                 return
 
             page = await context.new_page()
-            logging.info("DEBUG: getSpaces - Navigating to notion.so to warm up context...")
-            try:
-                await page.goto("https://www.notion.so/", wait_until="domcontentloaded", timeout=15000) # 15s timeout
-                logging.info("DEBUG: getSpaces - Warm-up navigation to notion.so complete.")
-            except PlaywrightError as nav_err:
-                logging.warning(f"DEBUG: getSpaces - Warm-up navigation to notion.so failed: {nav_err}. Proceeding with fetch anyway.")
+            await page.goto("https://www.notion.so/", wait_until="domcontentloaded", timeout=15000)
             
             # JavaScript to perform the fetch for getSpaces
             javascript_code_get_spaces = """
@@ -241,32 +223,30 @@ async def fetch_and_set_notion_ids(account: NotionAccount):
             """
             js_args = {"apiUrl": get_spaces_url, "headers": js_fetch_headers, "body": {}} # Empty JSON body for getSpaces
             
-            logging.info("Executing Playwright page.evaluate for getSpaces...")
             result = await page.evaluate(javascript_code_get_spaces, js_args)
 
             if not result or not result.get('success'):
                 error_detail = result.get('error', 'Unknown error during getSpaces JS execution')
-                logging.error(f"Playwright getSpaces call failed for account: {error_detail}")
-                logging.error(f"Failing cookie: {account.cookie}")
+                account_logger.error(f"Account validation failed: {error_detail}")
+                account_logger.error(f"Failing cookie: {account.cookie}")
                 account.is_healthy = False
                 return
 
             data = result.get('data')
             if not data:
-                logging.error("No data returned from successful getSpaces call for account.")
-                logging.error(f"Failing cookie: {account.cookie}")
+                account_logger.error("Account validation failed: No data returned")
+                account_logger.error(f"Failing cookie: {account.cookie}")
                 account.is_healthy = False
                 return
 
             # Extract user ID
             user_id_key = next(iter(data), None)
             if not user_id_key:
-                logging.error("Could not extract user ID from getSpaces response for account.")
-                logging.error(f"Failing cookie: {account.cookie}")
+                account_logger.error("Account validation failed: No user ID found")
+                account_logger.error(f"Failing cookie: {account.cookie}")
                 account.is_healthy = False
                 return
             account.user_id = user_id_key
-            logging.info(f"Fetched Notion User ID: {account.user_id}")
 
             # Extract space ID
             user_root = data.get(user_id_key, {}).get("user_root", {}).get(user_id_key, {})
@@ -310,90 +290,76 @@ async def fetch_and_set_notion_ids(account: NotionAccount):
                     """
                     analytics_args = {"apiUrl": get_user_analytics_url, "headers": analytics_headers, "body": {}}
                     
-                    logging.info(f"Executing Playwright to get email for User ID: {account.user_id}...")
                     analytics_result = await page.evaluate(javascript_code_get_analytics, analytics_args)
                     
                     if analytics_result and analytics_result.get('success'):
                         analytics_data = analytics_result.get('data')
                         account.user_email = analytics_data.get('user_email')
                         if account.user_email:
-                            logging.info(f"Fetched User Email: {account.user_email} for User ID: {account.user_id}")
-                            logging.info(f"Fetched Notion Space ID: {account.space_id} for User ID: {account.user_id}")
+                            account_logger.warning(f"Account validated: {account.user_email}")
                             account.is_healthy = True # Mark as healthy only on complete success
                         else:
-                            logging.error(f"Could not extract user_email for User ID: {account.user_id}")
-                            logging.error(f"Failing cookie: {account.cookie}")
+                            account_logger.error(f"Account validation failed: No email found for User ID: {account.user_id}")
+                            account_logger.error(f"Failing cookie: {account.cookie}")
                             account.is_healthy = False
                     else:
                         error_detail = analytics_result.get('error', 'Unknown error') if analytics_result else 'No result from JS'
-                        logging.error(f"getUserAnalyticsSettings call failed for User ID {account.user_id}: {error_detail}")
-                        logging.error(f"Failing cookie: {account.cookie}")
+                        account_logger.error(f"Account validation failed: getUserAnalyticsSettings error: {error_detail}")
+                        account_logger.error(f"Failing cookie: {account.cookie}")
                         account.is_healthy = False
                 else:
-                    logging.error(f"Could not extract spaceId for User ID: {account.user_id}")
-                    logging.error(f"Failing cookie: {account.cookie}")
+                    account_logger.error(f"Account validation failed: No spaceId for User ID: {account.user_id}")
+                    account_logger.error(f"Failing cookie: {account.cookie}")
                     account.is_healthy = False
             else:
-                logging.error(f"Could not find space_view_pointers or spaceId for User ID: {account.user_id}")
-                logging.error(f"Failing cookie: {account.cookie}")
+                account_logger.error(f"Account validation failed: No space_view_pointers for User ID: {account.user_id}")
+                account_logger.error(f"Failing cookie: {account.cookie}")
                 account.is_healthy = False
     
     except PlaywrightError as e:
-        logging.error(f"Playwright error during fetch_and_set_notion_ids for account: {e}")
-        logging.error(f"Failing cookie: {account.cookie}")
+        account_logger.error(f"Account validation failed: Playwright error: {e}")
+        account_logger.error(f"Failing cookie: {account.cookie}")
         account.is_healthy = False
     except Exception as e:
-        logging.error(f"General error during fetch_and_set_notion_ids for account: {e}")
-        logging.error(f"Failing cookie: {account.cookie}")
+        account_logger.error(f"Account validation failed: General error: {e}")
+        account_logger.error(f"Failing cookie: {account.cookie}")
         account.is_healthy = False
     finally:
-        # Prioritize closing the browser, which should handle its contexts/pages.
-        # Add checks to prevent errors if already closed.
         if browser and browser.is_connected():
             try:
-                logging.info("DEBUG: fetch_and_set_notion_ids - Closing browser...")
                 await browser.close()
-                logging.info("DEBUG: fetch_and_set_notion_ids - Browser closed.")
-            except PlaywrightError as e:
-                logging.warning(f"DEBUG: fetch_and_set_notion_ids - Ignoring error during browser close: {e}")
-            except Exception as e: # Catch potential unexpected errors during close
-                logging.warning(f"DEBUG: fetch_and_set_notion_ids - Ignoring unexpected error during browser close: {e}")
-        else:
-            # If browser is None or not connected, page/context are likely also invalid or already handled.
-            logging.info("DEBUG: fetch_and_set_notion_ids - Browser already closed or not initialized.")
-        
-        logging.info(f"fetch_and_set_notion_ids completed for account. Final status: {account}")
-
+            except:
+                pass  # Suppress any errors during browser close
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     # On startup
-    logging.info("Application startup: Initializing Notion accounts...")
+    account_logger.warning("Starting application: Initializing Notion accounts...")
 
     if NOTION_COOKIES_RAW:
         # Split cookies by a unique separator, e.g., '|'
         cookie_list = [c.strip() for c in NOTION_COOKIES_RAW.split('|') if c.strip()]
         for cookie in cookie_list:
             ACCOUNTS.append(NotionAccount(cookie=cookie))
-        logging.info(f"Loaded {len(ACCOUNTS)} Notion account(s) from environment variable.")
+        account_logger.warning(f"Loaded {len(ACCOUNTS)} Notion account(s) from environment variable.")
     
     if not ACCOUNTS:
-        logging.error("CRITICAL: No Notion accounts loaded. The application will not be able to process requests.")
+        account_logger.error("CRITICAL: No Notion accounts loaded. The application will not be able to process requests.")
     else:
-        # Concurrently fetch IDs for all accounts
-        logging.info("Fetching IDs for all loaded Notion accounts...")
+        # Concurrently fetch IDs for all loaded Notion accounts...
+        account_logger.warning("Fetching IDs for all Notion accounts...")
         fetch_tasks = [fetch_and_set_notion_ids(acc) for acc in ACCOUNTS]
         await asyncio.gather(*fetch_tasks)
 
         healthy_count = sum(1 for acc in ACCOUNTS if acc.is_healthy)
-        logging.info(f"Initialization complete. {healthy_count} of {len(ACCOUNTS)} accounts are healthy.")
+        account_logger.warning(f"Initialization complete. {healthy_count} of {len(ACCOUNTS)} accounts are healthy.")
 
         if healthy_count == 0:
-            logging.error("CRITICAL: No healthy Notion accounts available after initialization.")
+            account_logger.error("CRITICAL: No healthy Notion accounts available after initialization.")
     
     yield
-    # On shutdown (if any cleanup needed)
-    logging.info("Application shutdown.")
+    # On shutdown
+    account_logger.warning("Application shutdown.")
 
 app = FastAPI(lifespan=lifespan)
 
@@ -541,12 +507,10 @@ async def _run_playwright_fetch(
 
     # Construct headers for this specific task run
     current_headers = headers_template.copy()
-    current_headers['x-notion-space-id'] = account.space_id       # Use fetched space_id
-    if account.user_id: # Use fetched user_id for active user header
+    current_headers['x-notion-space-id'] = account.space_id
+    if account.user_id:
         current_headers['x-notion-active-user-header'] = account.user_id
     
-    # 'cookie' is handled by context.add_cookies(), so it's not in current_headers for fetch
-
     async def handle_chunk(chunk_str: str):
         await chunk_queue.put(chunk_str)
 
@@ -554,7 +518,6 @@ async def _run_playwright_fetch(
         await chunk_queue.put(None)
 
     try:
-        logging.info("DEBUG: Background task starting Playwright.")
         async with async_playwright() as p:
             # Configure browser launch with proxy if PROXY_URL is set
             launch_args = {
@@ -563,25 +526,11 @@ async def _run_playwright_fetch(
             }
             if PROXY_URL:
                 launch_args['proxy'] = {'server': PROXY_URL}
-                logging.info(f"DEBUG: Background task using proxy: {PROXY_URL}")
-            
-            try:
-                browser = await p.chromium.launch(**launch_args)
-            except PlaywrightError as e:
-                if PROXY_URL and "proxy" in str(e).lower():
-                    logging.error(f"Invalid proxy URL or proxy connection failed: {PROXY_URL}. Error: {e}")
-                    await handle_stream_end()  # Signal end of stream
-                    raise PlaywrightError(f"Proxy configuration error: {e}")
-                else:
-                    raise
             
-            logging.info("DEBUG: Background task browser launched.")
-            # Get user-agent from the constructed headers for this task
-            user_agent_for_context = current_headers.get('user-agent', 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36') # Default if not in template
-            context = await browser.new_context(user_agent=user_agent_for_context)
-            logging.info("DEBUG: Background task context created.")
+            browser = await p.chromium.launch(**launch_args)
+            context = await browser.new_context(user_agent=current_headers.get('user-agent', 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36'))
 
-            if account.cookie: # Use passed account cookie
+            if account.cookie:
                 cookies_to_add = []
                 cookie_pairs = account.cookie.split('; ')
                 for pair in cookie_pairs:
@@ -594,30 +543,24 @@ async def _run_playwright_fetch(
                         })
                 if cookies_to_add:
                     await context.add_cookies(cookies_to_add)
-                    logging.info("DEBUG: Background task cookies added.")
                 else:
-                    logging.warning("Warning: No valid cookies found in account cookie for background task.")
+                    raise ValueError("Server configuration error: No valid cookies for request")
             else:
-                 logging.error("Error: Account cookie is empty for background task.")
-                 raise ValueError("Server configuration error: Notion cookie not set for background task.")
+                 raise ValueError("Server configuration error: Notion cookie not set for request")
 
             page = await context.new_page()
-            logging.info("DEBUG: Background task page created.")
             await page.goto("https://www.notion.so/chat", wait_until="domcontentloaded")
-            logging.info("DEBUG: Background task navigation complete.")
 
             await page.expose_function("sendChunkToPython", handle_chunk)
             await page.expose_function("signalStreamEnd", handle_stream_end)
-            logging.info("DEBUG: Background task functions exposed.")
 
             request_body_json_str = notion_request_body.json()
             
             # Prepare headers for JS fetch (cookie is handled by context)
             js_fetch_headers = current_headers.copy()
-            if 'cookie' in js_fetch_headers: # Should not be there if template is correct
+            if 'cookie' in js_fetch_headers:
                 del js_fetch_headers['cookie']
 
-
             javascript_code = """
             async (args) => {
                 const { apiUrl, headers, body } = args;
@@ -655,31 +598,23 @@ async def _run_playwright_fetch(
             }
             """
             js_args = {"apiUrl": notion_api_url, "headers": js_fetch_headers, "body": request_body_json_str}
-            logging.info("DEBUG: Background task executing page.evaluate()...")
             js_result = await page.evaluate(javascript_code, js_args)
-            logging.info(f"DEBUG: Background task page.evaluate() result: {js_result}")
 
             if not js_result or not js_result.get('success'):
                 error_detail = js_result.get('error', 'Unknown JS execution error')
-                logging.error(f"Error in background task JS execution: {error_detail}")
                 # Error already signaled to queue by JS calling signalStreamEnd
                 # Re-raise to be caught by the task's main try/except
                 raise PlaywrightError(f"JS Fetch Error: {error_detail}")
 
     except Exception as e:
-        logging.error(f"Error in _run_playwright_fetch background task: {e}")
         await chunk_queue.put(None) # Ensure queue is terminated on error
         # Exception will be caught by playwright_task.exception() in the main generator
     finally:
-        logging.info("DEBUG: Background task _run_playwright_fetch attempting to close browser.")
         if browser and browser.is_connected():
             try:
                 await browser.close()
-                logging.info("DEBUG: Background task browser closed.")
-            except Exception as e:
-                logging.warning(f"Ignoring error during background task browser close: {e}")
-        else:
-            logging.info("DEBUG: Background task browser already closed or not initialized.")
+            except:
+                pass  # Suppress any errors during browser close
 
 # --- Main Generator Called by Endpoint ---
 async def stream_notion_response(notion_request_body: NotionRequestBody, account: NotionAccount):
@@ -692,8 +627,6 @@ async def stream_notion_response(notion_request_body: NotionRequestBody, account
     created_time = int(time.time())
 
     # Define the template for headers here, to be passed to the background task
-    # The background task will then add/override specific headers like x-notion-space-id
-    # It will also fetch NOTION_ACTIVE_USER_HEADER from os.getenv()
     headers_template = {
         'accept': 'application/x-ndjson',
         'accept-language': 'en-US,en;q=0.9',
@@ -711,12 +644,10 @@ async def stream_notion_response(notion_request_body: NotionRequestBody, account
         'sec-fetch-site': 'same-origin',
         'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36',
         # 'cookie' and 'x-notion-space-id' will be handled/added by _run_playwright_fetch
-        # using the passed environment variable strings
     }
 
     try:
         # Health check is now performed by get_next_account() before this function is called.
-        logging.info("DEBUG: Main generator starting Playwright background task.")
         playwright_task = asyncio.create_task(
             _run_playwright_fetch(
                 chunk_queue,
@@ -728,11 +659,9 @@ async def stream_notion_response(notion_request_body: NotionRequestBody, account
         )
 
         accumulated_line = ""
-        logging.info("DEBUG: Main generator starting queue processing loop.")
         while True:
             chunk = await chunk_queue.get() # Wait for a chunk from the background task
             if chunk is None:
-                logging.info("DEBUG: Main generator received None sentinel from queue.")
                 break
 
             accumulated_line += chunk
@@ -749,15 +678,14 @@ async def stream_notion_response(notion_request_body: NotionRequestBody, account
                                 id=chunk_id, created=created_time,
                                 choices=[Choice(delta=ChoiceDelta(content=content_chunk))]
                             )
-                            logging.info(f"DEBUG: Main generator yielding chunk: {content_chunk[:50]}...")
                             yield f"data: {sse_chunk.json()}\n\n"
-                            # No asyncio.sleep(0) here, as yielding should be enough
                     elif "recordMap" in data:
-                         logging.info("DEBUG: Main generator detected recordMap, ignoring.")
+                         pass # Ignore recordMap chunks 
                 except json.JSONDecodeError:
-                    logging.warning(f"Warning: Main generator could not decode JSON line: {line}")
+                    pass # Ignore JSON decode errors in silent mode
                 except Exception as e:
-                    logging.error(f"Error processing line in main generator: {line} - {e}")
+                    # Only log critical errors
+                    account_logger.error(f"Critical error processing stream: {e}")
         
         # Process any final accumulated data after None sentinel
         if accumulated_line.strip():
@@ -770,47 +698,40 @@ async def stream_notion_response(notion_request_body: NotionRequestBody, account
                              id=chunk_id, created=created_time,
                              choices=[Choice(delta=ChoiceDelta(content=content_chunk))]
                          )
-                         logging.info(f"DEBUG: Main generator yielding final accumulated chunk: {content_chunk[:50]}...")
                          yield f"data: {sse_chunk.json()}\n\n"
              except json.JSONDecodeError:
-                 logging.warning(f"Warning: Main generator could not decode final JSON line: {accumulated_line}")
+                 pass # Ignore JSON decode errors in silent mode
              except Exception as e:
-                 logging.error(f"Error processing final line in main generator: {accumulated_line} - {e}")
+                 # Only log critical errors
+                 account_logger.error(f"Critical error processing final data: {e}")
 
         # After loop, check if the background task raised an exception
         if playwright_task.done() and playwright_task.exception():
             task_exception = playwright_task.exception()
-            logging.error(f"Playwright background task failed: {task_exception}")
-            raise HTTPException(status_code=500, detail=f"Error during background browser automation: {task_exception}")
+            account_logger.error(f"Background task error: {task_exception}")
+            raise HTTPException(status_code=500, detail=f"Error during background processing: {task_exception}")
         else:
-            logging.info("DEBUG: Main generator background task completed successfully.")
             final_chunk = ChatCompletionChunk(
                 id=chunk_id, created=created_time,
                 choices=[Choice(delta=ChoiceDelta(), finish_reason="stop")]
             )
-            logging.info("DEBUG: Main generator yielding final stop chunk.")
             yield f"data: {final_chunk.json()}\n\n"
-            logging.info("DEBUG: Main generator yielding [DONE] marker.")
             yield "data: [DONE]\n\n"
 
     except Exception as e:
-        logging.error(f"Error in main stream_notion_response generator: {e}")
+        account_logger.error(f"Stream response error: {e}")
         if playwright_task and not playwright_task.done():
-            logging.info("DEBUG: Main generator cancelling background task due to its own error.")
             playwright_task.cancel()
         raise
     finally:
-        logging.info("DEBUG: Main generator finished.")
         if playwright_task and not playwright_task.done():
-            logging.info("DEBUG: Main generator ensuring background task is cancelled on exit.")
             playwright_task.cancel()
             try:
                 await playwright_task # Allow cancellation to propagate
             except asyncio.CancelledError:
-                logging.info("DEBUG: Background task successfully cancelled.")
-            except Exception as e:
-                logging.error(f"DEBUG: Error during background task cancellation/await: {e}")
-
+                pass
+            except Exception:
+                pass # Suppress errors during cleanup
 
 # --- API Endpoint ---
 
@@ -847,16 +768,12 @@ async def chat_completions(request_data: ChatCompletionRequest, request: Request
             media_type="text/event-stream"
         )
     else:
-        # --- Non-Streaming Logic (Optional - Collects stream internally) ---
-        # Note: The primary goal is streaming, but a non-streaming version
-        # might be useful for testing or simpler clients.
-        # This requires collecting all chunks from the async generator.
+        # --- Non-Streaming Logic ---
         full_response_content = ""
         final_finish_reason = None
         chunk_id = f"chatcmpl-{uuid.uuid4()}" # Generate ID for the non-streamed response
         created_time = int(time.time())
 
-        # --- Non-streaming logic needs to call the generator with the selected account ---
         try:
             # Call the Playwright generator, passing the selected account
             async for line in stream_notion_response(notion_request_body, account):
@@ -874,7 +791,9 @@ async def chat_completions(request_data: ChatCompletionRequest, request: Request
                                 if finish_reason:
                                     final_finish_reason = finish_reason
                     except json.JSONDecodeError:
-                        print(f"Warning: Could not decode JSON line in non-streaming mode: {line}")
+                        pass # Ignore JSON errors in non-streaming mode
+                    except Exception as e:
+                        account_logger.error(f"Error processing non-streaming response: {e}")
 
             # Construct the final OpenAI-compatible non-streaming response
             return {
@@ -902,13 +821,10 @@ async def chat_completions(request_data: ChatCompletionRequest, request: Request
              # Re-raise HTTP exceptions from the streaming function
              raise e
         except Exception as e:
-            print(f"Error during non-streaming processing: {e}")
+            account_logger.error(f"Error during non-streaming processing: {e}")
             raise HTTPException(status_code=500, detail="Internal server error processing Notion response")
 
-
 # --- Uvicorn Runner ---
-# Allows running with `python main.py` for simple testing,
-# but `uvicorn main:app --reload` is recommended for development.
 if __name__ == "__main__":
     import uvicorn
     print("Starting server. Access at http://127.0.0.1:7860")