Upload 9 files

.gitignore

@@ -0,0 +1,32 @@
+# Environment variables
+.env
+
+# Python artifacts
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environment
+.venv
+venv/
+ENV/
+env/

Dockerfile

@@ -0,0 +1,31 @@
+# Use an official Python runtime as a parent image
+FROM python:3.10-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file into the container at /app
+COPY requirements.txt .
+
+# Install any needed packages specified in requirements.txt
+# Use --no-cache-dir to reduce image size
+# Use --upgrade to ensure latest versions are installed
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Install Playwright browser binaries (specifically Chromium by default)
+RUN playwright install chromium --with-deps
+
+# Copy the current directory contents into the container at /app
+COPY main.py .
+COPY models.py .
+
+# Make port 8000 available to the world outside this container
+EXPOSE 7860
+
+# Define environment variables (placeholders, will be set at runtime)
+ENV NOTION_COOKIE=""
+ENV NOTION_SPACE_ID=""
+
+# Run uvicorn when the container launches
+# Use 0.0.0.0 to make it accessible externally
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 gzzhongqi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

PLAN.md

@@ -0,0 +1,75 @@
+# Plan: Integrate Browser Automation using Playwright
+
+**Problem:** Direct API requests to Notion using `httpx` are failing, likely due to server-side checks (e.g., TLS fingerprinting).
+
+**Solution:** Replace the direct `httpx` calls with browser automation using Playwright to mimic a real browser environment.
+
+**Steps:**
+
+1.  **Add Dependency:**
+    *   Add `playwright` to the [`requirements.txt`](requirements.txt) file.
+    *   *Note:* After updating requirements, the browser binaries for Playwright will need to be installed (typically via `playwright install` in the terminal).
+
+2.  **Modify `stream_notion_response` Function ([`main.py:184`](main.py:184)):**
+    *   **Remove `httpx`:** Delete the `async with httpx.AsyncClient(...)` block ([`main.py:216-263`](main.py:216)). Keep the surrounding error handling for now.
+    *   **Initialize Playwright:** Add code to start Playwright, launch a Chromium browser instance, and create a new browser context.
+    *   **Set Cookie:** Add the `NOTION_COOKIE` ([`main.py:26`](main.py:26)) to the browser context.
+    *   **Create Page:** Open a new page within the context.
+    *   **Execute Request via JavaScript:** Use `page.evaluate()` to run JavaScript code within the browser page. This JavaScript code will:
+        *   Use the `fetch` API to make the POST request to [`NOTION_API_URL`](main.py:24).
+        *   Include the necessary headers (copied from the original [`headers`](main.py:186) dictionary).
+        *   Send the `notion_request_body` (serialized as JSON, similar to [`main.py:218`](main.py:218)).
+        *   Handle the streaming response (`response.body.getReader()`) from `fetch`.
+        *   Read chunks from the stream (`reader.read()`) and send them back to the Python environment (e.g., using `page.expose_function` to call a Python callback).
+    *   **Process Streamed Chunks in Python:** The Python callback function (exposed to JS) will receive the raw chunks from the browser. This callback will need to decode the chunks (likely UTF-8) and process the `ndjson` lines similarly to the original code ([`main.py:228-249`](main.py:228)), yielding the formatted SSE chunks.
+    *   **Handle End of Stream:** Ensure the `[DONE]` message is sent correctly after the browser stream finishes.
+    *   **Cleanup:** Close the page, context, and browser instance properly (initially on a per-request basis).
+    *   **Update Error Handling:** Adapt the `try...except` blocks to catch potential Playwright-specific errors.
+
+**Diagram:**
+
+```mermaid
+graph TD
+    A[FastAPI Request /v1/chat/completions] --> B{Stream?};
+    B -- Yes --> C[Call stream_notion_response];
+    B -- No --> D[Call stream_notion_response internally];
+
+    subgraph stream_notion_response (Modified w/ Playwright)
+        E[Build NotionRequestBody] --> F;
+        F[Initialize Playwright & Launch Browser] --> G;
+        G[Create Context & Add Cookie] --> H;
+        H[Create Page & Expose Python Callback] --> I;
+        I[page.evaluate(): JS Fetch POST to Notion] --> J;
+        J[JS: Read Stream Chunks] --> K;
+        K[JS: Send Chunk to Python Callback] --> L;
+        L[Python Callback: Decode & Process Chunk] --> M;
+        M[Yield Formatted SSE Chunk] --> N{End of Stream?};
+        N -- No --> J;
+        N -- Yes --> O[Yield [DONE] Chunk];
+        O --> P[Cleanup Playwright (Page, Context, Browser)];
+    end
+
+    C --> Q[Return StreamingResponse];
+    D --> R[Collect Chunks from stream_notion_response];
+    R --> S[Format Non-Streaming Response];
+    S --> T[Return JSON Response];
+    Q --> U[Client Receives SSE Stream];
+    T --> U;
+
+    style F fill:#f9f,stroke:#333,stroke-width:2px
+    style G fill:#f9f,stroke:#333,stroke-width:2px
+    style H fill:#f9f,stroke:#333,stroke-width:2px
+    style I fill:#f9f,stroke:#333,stroke-width:2px
+    style J fill:#f9f,stroke:#333,stroke-width:2px
+    style K fill:#f9f,stroke:#333,stroke-width:2px
+    style L fill:#ccf,stroke:#333,stroke-width:1px
+    style M fill:#ccf,stroke:#333,stroke-width:1px
+    style O fill:#ccf,stroke:#333,stroke-width:1px
+    style P fill:#f9f,stroke:#333,stroke-width:2px
+```
+
+**Agreed Choices:**
+
+*   Dependency: `playwright`
+*   Browser: Chromium
+*   Browser Lifecycle: Launch/Close per request (initial approach)

README.md

@@ -1,10 +1,132 @@
 ---
-title: Notion2api
-emoji: 🌍
-colorFrom: gray
-colorTo: yellow
+title: Notion API Bridge
+emoji: 🌉
+colorFrom: blue
+colorTo: purple
 sdk: docker
+app_port: 7860
 pinned: false
+license: mit # Or choose another appropriate license if preferred
+# Add any other relevant tags or configuration if needed
 ---
+# OpenAI to Notion API Bridge
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+This project provides a FastAPI application that acts as a bridge between OpenAI-compatible API calls and the Notion API, allowing you to interact with Notion using standard OpenAI tools and libraries.
+
+## Environment Variables
+
+The application requires the following environment variables to be set:
+
+*   `NOTION_COOKIE`: Your Notion complete cookie value. This is used for authentication with the Notion API. You can typically find this in your browser's developer tools while logged into Notion.
+*   `NOTION_SPACE_ID`: The ID of the Notion Space you want the API to interact with (`x-notion-space-id in header`).
+*   `PROXY_AUTH_TOKEN` (Optional): The Bearer token required for authentication to access the API endpoints. If not set, it defaults to `default_token`.
+*   `NOTION_ACTIVE_USER_HEADER` (Optional): If set, its value will be used for the `x-notion-active-user-header` in requests sent to the Notion API. If not set or empty, the header is omitted.
+*   `PROXY_URL` (Optional): URL of a proxy server to route all network connections through. If not set or empty, no proxy is used. Supports both HTTP and SOCKS5 proxies. Examples:
+    *   HTTP proxy: `http://proxy.example.com:8080`
+    *   SOCKS5 proxy: `socks5://proxy.example.com:1080`
+    
+    This proxy configuration affects all network connections made by the application through the Playwright browser automation.
+
+## Running Locally (without Docker)
+
+1.  Ensure you have Python 3.10+ installed.
+2.  Install dependencies:
+    ```bash
+    pip install -r requirements.txt
+    ```
+3.  Create a `.env` file in the project root with your `NOTION_COOKIE`:
+    ```dotenv
+    NOTION_COOKIE="your_cookie_value_here"
+    NOTION_SPACE_ID="your_space_id_here"
+    # PROXY_AUTH_TOKEN="your_secure_token" # Optional, defaults to default_token
+    # NOTION_ACTIVE_USER_HEADER="your_user_id" # Optional
+    # PROXY_URL="http://proxy.example.com:8080" # Optional, for HTTP proxy
+    # PROXY_URL="socks5://proxy.example.com:1080" # Optional, for SOCKS5 proxy
+    ```
+4.  Run the application using Uvicorn:
+    ```bash
+    uvicorn main:app --reload --port 7860
+    ```
+    The server will be available at `http://localhost:7860`. You will need to provide the correct token (either the default `default_token` or the one set in `.env`) via an `Authorization: Bearer <token>` header. The `NOTION_SPACE_ID` will be loaded from the `.env` file.
+
+## Running with Docker Compose (Recommended for Local Dev)
+
+This method uses the `docker-compose.yml` file for a streamlined local development setup. It automatically builds the image if needed and loads environment variables directly from your `.env` file.
+
+1.  Ensure you have Docker and Docker Compose installed.
+2.  Make sure your `.env` file exists in the project root with your `NOTION_COOKIE`, `NOTION_SPACE_ID`, and optionally `PROXY_AUTH_TOKEN`, `NOTION_ACTIVE_USER_HEADER`, and `PROXY_URL`. If `PROXY_AUTH_TOKEN` is not in the `.env` file, the default `default_token` will be used. If `NOTION_ACTIVE_USER_HEADER` is not set or empty, the corresponding header will not be sent. If `PROXY_URL` is not set or empty, no proxy will be used.
+3.  Run the following command in the project root:
+    ```bash
+    docker-compose up --build -d
+    ```
+    *   `--build`: Rebuilds the image if the `Dockerfile` or context has changed.
+    *   `-d`: Runs the container in detached mode (in the background).
+4.  The application will be accessible locally at `http://localhost:8139`. Environment variables like `NOTION_COOKIE` and `NOTION_SPACE_ID` will be loaded automatically from the `.env` file.
+
+To stop the service, run:
+```bash
+docker-compose down
+```
+
+## Running with Docker Command (Manual)
+
+This method involves building and running the Docker container manually, passing environment variables directly in the command.
+
+1.  **Build the Docker image:**
+    ```bash
+    docker build -t notion-api-bridge .
+    ```
+2.  **Run the Docker container:**
+    Replace `"your_cookie_value"` with your actual Notion cookie.
+    ```bash
+    docker run -p 7860:7860 \
+      -e NOTION_COOKIE="your_cookie_value" \
+      -e NOTION_SPACE_ID="your_space_id" \
+      -e PROXY_AUTH_TOKEN="your_token" \ # Set your desired token here
+      # -e NOTION_ACTIVE_USER_HEADER="your_user_id" \ # Optional: Set the active user header
+      # -e PROXY_URL="http://proxy.example.com:8080" \ # Optional: Set proxy URL
+      notion-api-bridge
+    ```
+    The server will be available at `http://localhost:7860` (or whichever host port you mapped to the container's 7860). You will need to use the token provided in the `-e PROXY_AUTH_TOKEN` flag via an `Authorization: Bearer <token>` header for authentication. The `NOTION_SPACE_ID` is passed directly via the `-e` flag.
+
+## Deploying to Hugging Face Spaces
+
+This application is designed to be easily deployed as a Docker Space on Hugging Face.
+
+1.  **Create a new Space:** Go to Hugging Face and create a new Space, selecting "Docker" as the Space SDK. Choose a name (e.g., `notion-api-bridge`).
+2.  **Upload Files:** Upload the `Dockerfile`, `main.py`, `models.py`, and `requirements.txt` to your Space repository. You can do this via the web interface or by cloning the repository and pushing the files. **Do not upload your `.env` file.**
+3.  **Add Secrets:** In your Space settings, navigate to the "Secrets" section. Add two secrets:
+    *   `NOTION_COOKIE`: Paste your Notion `token_v2` cookie value.
+    *   `NOTION_SPACE_ID`: Paste the ID of the target Notion Space.
+    *   `PROXY_AUTH_TOKEN`: Paste the desired Bearer token for API authentication (e.g., a strong, generated token). If you omit this, the default `default_token` will be used.
+    *   `NOTION_ACTIVE_USER_HEADER` (Optional): Paste the user ID to be sent in the `x-notion-active-user-header`. If omitted, the header will not be sent.
+    *   `PROXY_URL` (Optional): Paste the proxy server URL if you need to route connections through a proxy. Supports both HTTP (e.g., `http://proxy.example.com:8080`) and SOCKS5 (e.g., `socks5://proxy.example.com:1080`) proxies.
+    Hugging Face will securely inject these secrets as environment variables into your running container.
+4.  **Deployment:** Hugging Face Spaces will automatically build the Docker image from your `Dockerfile` and run the container. It detects applications running on port 7860 (as specified in the `Dockerfile` and metadata).
+5.  **Accessing the API:** Once the Space is running, you can access the API endpoint at the Space's public URL, providing the token via an `Authorization: Bearer <token>` header. The token must match the `PROXY_AUTH_TOKEN` secret you set (or the default `default_token`). The `NOTION_SPACE_ID` will be used automatically based on the secret you configured.
+
+    **Example using `curl` (replace `your_token` and URL):**
+    ```bash
+    # Example for Hugging Face Space (using token from HF Secret)
+    # Replace YOUR_HF_TOKEN with the value you set in the PROXY_AUTH_TOKEN secret
+    curl -X POST https://your-username-your-space-name.hf.space/v1/chat/completions \
+      -H "Authorization: Bearer YOUR_HF_TOKEN" \
+      -H "Content-Type: application/json" \
+      -d '{
+            "model": "notion-model", # Specify a Notion model like "openai-gpt-4.1"
+            "messages": [{"role": "user", "content": "Summarize this document."}],
+            "stream": false,
+            "notion_model": "openai-gpt-4.1" # Required field for Notion
+          }'
+
+    # Example for Localhost (using default token 'default_token')
+    # If you set a different token in .env or via -e, use that instead.
+    curl -X POST http://localhost:7860/v1/chat/completions \
+      -H "Authorization: Bearer default_token" \
+      -H "Content-Type: application/json" \
+      -d '{
+            "model": "notion-model",
+            "messages": [{"role": "user", "content": "What is the capital of France?"}],
+            "stream": true,
+            "notion_model": "anthropic-sonnet-4" # Required field for Notion
+          }'

docker-compose.yml

@@ -0,0 +1,8 @@
+version: '3.8'
+services:
+  notion-bridge:
+    build: .
+    ports:
+      - "8139:7860" # Map host port 8139 to container port 7860
+    env_file:
+      - .env

main.py

@@ -0,0 +1,853 @@
+import asyncio
+import sys # For platform check
+import logging
+import os
+import uuid
+import json
+import time
+import random
+import asyncio
+import httpx # For getSpaces API call
+from contextlib import asynccontextmanager # For lifespan
+from playwright.async_api import async_playwright, Error as PlaywrightError
+from fastapi import FastAPI, Request, HTTPException, Depends, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from fastapi.responses import StreamingResponse
+from dotenv import load_dotenv
+import secrets # Added for secure comparison
+from datetime import datetime, timedelta, timezone # Explicit datetime imports
+from zoneinfo import ZoneInfo # For timezone handling
+from typing import List, Optional # Add List and Optional for typing
+from models import (
+    ChatMessage, ChatCompletionRequest, NotionTranscriptConfigValue,
+    NotionTranscriptContextValue, NotionTranscriptItem, NotionDebugOverrides,
+    NotionRequestBody, ChoiceDelta, Choice, ChatCompletionChunk, Model, ModelList
+)
+
+# Load environment variables from .env file
+load_dotenv()
+
+# --- Event Loop Policy for Windows ---
+# For Playwright compatibility, especially with subprocesses on Windows
+if sys.platform == "win32":
+    asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
+    logging.info("Set WindowsProactorEventLoopPolicy for asyncio.")
+
+# --- Logging Configuration ---
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# --- Account Management Class ---
+class NotionAccount:
+    """Represents a single Notion account with its cookie and fetched IDs."""
+    def __init__(self, cookie: str):
+        self.cookie = cookie
+        self.space_id: Optional[str] = None
+        self.user_id: Optional[str] = None
+        self.is_healthy: bool = False
+        self.lock = asyncio.Lock() # To prevent concurrent fetches for the same account
+
+    def __str__(self):
+        return f"Account(user_id={self.user_id}, space_id={self.space_id}, healthy={self.is_healthy})"
+
+# --- Configuration ---
+NOTION_API_URL = "https://www.notion.so/api/v3/runInferenceTranscript"
+# IMPORTANT: Load multiple Notion cookies securely from environment variables
+# Use a unique separator like '|' because cookies can contain ';' and ','
+NOTION_COOKIES_RAW = os.getenv("NOTION_COOKIES")
+
+# --- Global State for Account Polling ---
+ACCOUNTS: List[NotionAccount] = []
+CURRENT_ACCOUNT_INDEX = 0 # Index for round-robin
+
+if not NOTION_COOKIES_RAW:
+    # This is a critical error, app cannot function without it.
+    logging.error("CRITICAL: NOTION_COOKIES environment variable not set. Application will not work.")
+    # In a real app, you might exit or raise a more severe startup error.
+
+# --- Proxy Configuration ---
+PROXY_URL = os.getenv("PROXY_URL", "")  # Empty string as default
+
+# --- Authentication ---
+EXPECTED_TOKEN = os.getenv("PROXY_AUTH_TOKEN", "default_token") # Default token
+security = HTTPBearer()
+
+def authenticate(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    """Compares provided token with the expected token."""
+    correct_token = secrets.compare_digest(credentials.credentials, EXPECTED_TOKEN)
+    if not correct_token:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid authentication credentials",
+            # WWW-Authenticate header removed for Bearer
+        )
+    return True # Indicate successful authentication
+
+# --- 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.
+    """
+    global CURRENT_ACCOUNT_INDEX
+    
+    # This check runs on every request to ensure we don't try to select from an empty list
+    # in case all accounts failed during startup.
+    if not ACCOUNTS:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="No Notion accounts are configured in the server."
+        )
+
+    healthy_accounts = [acc for acc in ACCOUNTS if acc.is_healthy]
+    if not healthy_accounts:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            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.
+    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 with User ID: {account.user_id} for request.")
+            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.")
+        account.is_healthy = False
+        return
+
+    get_spaces_url = "https://www.notion.so/api/v3/getSpaces"
+    # Headers for the JS fetch call (cookie is handled by context)
+    js_fetch_headers = {
+        'Content-Type': 'application/json',
+        '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
+        'origin': 'https://www.notion.so',
+        'priority': 'u=1, i',
+        'referer': 'https://www.notion.so/', # Simplified
+        '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"',
+        'sec-fetch-dest': 'empty',
+        'sec-fetch-mode': 'cors',
+        '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'
+    }
+
+    browser = None
+    context = None
+    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 = {
+                'headless': True,
+                'args': ['--no-sandbox', '--disable-setuid-sandbox']
+            }
+            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
+            
+            context = await browser.new_context(user_agent=js_fetch_headers['user-agent'])
+
+            # Add cookies from the account's cookie string
+            cookies_to_add = []
+            cookie_pairs = account.cookie.split('; ')
+            for pair in cookie_pairs:
+                if '=' in pair:
+                    name, value = pair.split('=', 1)
+                    cookies_to_add.append({
+                        'name': name.strip(), 'value': value.strip(),
+                        'domain': '.notion.so', 'path': '/',
+                        'secure': True, 'httpOnly': True, 'sameSite': 'Lax'
+                    })
+            if cookies_to_add:
+                await context.add_cookies(cookies_to_add)
+            else:
+                logging.error("No valid cookies parsed from account's cookie for getSpaces.")
+                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.")
+            
+            # JavaScript to perform the fetch for getSpaces
+            javascript_code_get_spaces = """
+            async (args) => {
+                const { apiUrl, headers, body } = args;
+                try {
+                    const response = await fetch(apiUrl, {
+                        method: 'POST',
+                        headers: headers,
+                        body: JSON.stringify(body) // Ensure body is stringified
+                    });
+                    if (!response.ok) {
+                        console.error('getSpaces Fetch error:', response.status, await response.text());
+                        return { success: false, error: `HTTP ${response.status}` };
+                    }
+                    const data = await response.json();
+                    return { success: true, data: data };
+                } catch (error) {
+                    console.error('getSpaces JS Exception:', error);
+                    return { success: false, error: error.toString() };
+                }
+            }
+            """
+            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}")
+                account.is_healthy = False
+                return
+
+            data = result.get('data')
+            if not data:
+                logging.error("No data returned from successful getSpaces call for account.")
+                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.")
+                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, {})
+            space_view_pointers = user_root.get("value", {}).get("value", {}).get("space_view_pointers", [])
+            if space_view_pointers and isinstance(space_view_pointers, list) and len(space_view_pointers) > 0:
+                account.space_id = space_view_pointers[0].get("spaceId")
+                if account.space_id:
+                    logging.info(f"Fetched Notion Space ID: {account.space_id} for User ID: {account.user_id}")
+                    account.is_healthy = True # Mark as healthy on complete success
+                else:
+                    logging.error(f"Could not extract spaceId for User ID: {account.user_id}")
+                    account.is_healthy = False
+            else:
+                logging.error(f"Could not find space_view_pointers or spaceId for User ID: {account.user_id}")
+                account.is_healthy = False
+    
+    except PlaywrightError as e:
+        logging.error(f"Playwright error during fetch_and_set_notion_ids for account: {e}")
+        account.is_healthy = False
+    except Exception as e:
+        logging.error(f"General error during fetch_and_set_notion_ids for account: {e}")
+        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}")
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # On startup
+    logging.info("Application startup: 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.")
+    
+    if not ACCOUNTS:
+        logging.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...")
+        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.")
+
+        if healthy_count == 0:
+            logging.error("CRITICAL: No healthy Notion accounts available after initialization.")
+    
+    yield
+    # On shutdown (if any cleanup needed)
+    logging.info("Application shutdown.")
+
+app = FastAPI(lifespan=lifespan)
+
+# --- Helper Functions ---
+
+def build_notion_request(request_data: ChatCompletionRequest, account: NotionAccount) -> NotionRequestBody:
+    """Transforms OpenAI-style messages to Notion transcript format, using the provided account."""
+    
+    # --- Timestamp and User ID Logic ---
+    # Use the user ID from the selected account
+    user_id = account.user_id
+    # Get all non-assistant messages to assign timestamps
+    non_assistant_messages = [msg for msg in request_data.messages if msg.role != "assistant"]
+    num_non_assistant_messages = len(non_assistant_messages)
+    message_timestamps = {} # Store timestamps keyed by message id
+
+    if num_non_assistant_messages > 0:
+        # Get current time specifically in Pacific Time (America/Los_Angeles)
+        pacific_tz = ZoneInfo("America/Los_Angeles")
+        now_pacific = datetime.now(timezone.utc).astimezone(pacific_tz)
+
+        # Assign timestamp to the last non-assistant message
+        last_msg_id = non_assistant_messages[-1].id
+        message_timestamps[last_msg_id] = now_pacific
+
+        # Calculate timestamps for previous non-assistant messages (random intervals earlier)
+        current_timestamp = now_pacific
+        for i in range(num_non_assistant_messages - 2, -1, -1): # Iterate backwards from second-to-last
+            current_timestamp -= timedelta(minutes=random.randint(3, 20)) # Use random interval (3-20 mins)
+            message_timestamps[non_assistant_messages[i].id] = current_timestamp
+
+    # --- Build Transcript ---
+    # Get current time in Pacific timezone for context
+    pacific_tz = ZoneInfo("America/Los_Angeles")
+    now_pacific = datetime.now(timezone.utc).astimezone(pacific_tz)
+    # Format timestamp exactly as YYYY-MM-DDTHH:MM:SS.fff-HH:MM
+    dt_str = now_pacific.strftime("%Y-%m-%dT%H:%M:%S")
+    ms = f"{now_pacific.microsecond // 1000:03d}" # Ensure 3 digits for milliseconds
+    tz_str = now_pacific.strftime("%z") # Gets +HHMM or -HHMM
+    formatted_tz = f"{tz_str[:-2]}:{tz_str[-2:]}" # Insert colon
+    current_datetime_iso = f"{dt_str}.{ms}{formatted_tz}"
+    
+    # Generate random text for userName and spaceName
+    random_words = ["Project", "Workspace", "Team", "Studio", "Lab", "Hub", "Zone", "Space"]
+    user_name = f"User{random.randint(100, 999)}"
+    space_name = f"{random.choice(random_words)} {random.randint(1, 99)}"
+    
+    transcript = [
+        NotionTranscriptItem(
+            type="config",
+            value=NotionTranscriptConfigValue(model=request_data.notion_model)
+        ),
+        NotionTranscriptItem(
+            type="context",
+            value=NotionTranscriptContextValue(
+                userId=user_id or "",  # Use the user_id from the selected account
+                spaceId=account.space_id, # Use space_id from the selected account
+                surface="home_module",
+                timezone="America/Los_Angeles",
+                userName=user_name,
+                spaceName=space_name,
+                spaceViewId=str(uuid.uuid4()),  # Random UUID for spaceViewId
+                currentDatetime=current_datetime_iso
+            )
+        ),
+        NotionTranscriptItem(
+            type="agent-integration"
+            # No value field needed for agent-integration
+        )
+    ]
+
+    for message in request_data.messages:
+        if message.role == "assistant":
+            # Assistant messages get type="markdown-chat" and a traceId
+            transcript.append(NotionTranscriptItem(
+                type="markdown-chat",
+                value=message.content,
+                traceId=str(uuid.uuid4()) # Generate unique traceId for assistant message
+            ))
+        else: # Treat all other roles (user, system, etc.) as "user" type
+            created_at_dt = message_timestamps.get(message.id) # Use the unified timestamp dict
+            created_at_iso = None
+            if created_at_dt:
+                # Format timestamp exactly as YYYY-MM-DDTHH:MM:SS.fff-HH:MM
+                dt_str = created_at_dt.strftime("%Y-%m-%dT%H:%M:%S")
+                ms = f"{created_at_dt.microsecond // 1000:03d}" # Ensure 3 digits for milliseconds
+                tz_str = created_at_dt.strftime("%z") # Gets +HHMM or -HHMM
+                formatted_tz = f"{tz_str[:-2]}:{tz_str[-2:]}" # Insert colon
+                created_at_iso = f"{dt_str}.{ms}{formatted_tz}"
+
+            content = message.content
+            # Ensure content is treated as a string for user/system messages
+            if isinstance(content, list):
+                 # Attempt to extract text from list format, default to empty string
+                 text_content = ""
+                 for part in content:
+                     if isinstance(part, dict) and part.get("type") == "text":
+                         text_part = part.get("text")
+                         if isinstance(text_part, str):
+                             text_content += text_part # Concatenate text parts if needed
+                 content = text_content if text_content else "" # Use extracted text or empty string
+            elif not isinstance(content, str):
+                 content = "" # Default to empty string if not list or string
+
+            # Format value as expected by Notion for user type: [[content_string]]
+            notion_value = [[content]] if content else [[""]]
+
+            transcript.append(NotionTranscriptItem(
+                type="user", # Set type to "user" for non-assistant roles
+                value=notion_value,
+                userId=user_id, # Assign userId
+                createdAt=created_at_iso # Assign timestamp
+                # No traceId for user/system messages
+            ))
+
+    # Use spaceId from the selected account, set createThread=True
+    return NotionRequestBody(
+        spaceId=account.space_id, # From selected account
+        transcript=transcript,
+        createThread=True,       # Always create a new thread
+        # Generate a new traceId for each request
+        traceId=str(uuid.uuid4()),
+        # Explicitly set debugOverrides, generateTitle, and saveAllThreadOperations
+        debugOverrides=NotionDebugOverrides(
+            cachedInferences={},
+            annotationInferences={},
+            emitInferences=False
+        ),
+        generateTitle=False,
+        saveAllThreadOperations=False
+    )
+
+# --- Background Playwright Task ---
+async def _run_playwright_fetch(
+    chunk_queue: asyncio.Queue,
+    notion_request_body: NotionRequestBody,
+    headers_template: dict,
+    notion_api_url: str,
+    account: NotionAccount # Pass the whole account object
+):
+    """Runs Playwright fetch in the background, putting results into a queue."""
+    browser = None
+    context = None
+    page = None
+
+    # 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-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)
+
+    async def handle_stream_end():
+        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 = {
+                'headless': True,
+                'args': ['--no-sandbox', '--disable-setuid-sandbox']
+            }
+            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.")
+
+            if account.cookie: # Use passed account cookie
+                cookies_to_add = []
+                cookie_pairs = account.cookie.split('; ')
+                for pair in cookie_pairs:
+                    if '=' in pair:
+                        name, value = pair.split('=', 1)
+                        cookies_to_add.append({
+                            'name': name.strip(), 'value': value.strip(),
+                            'domain': '.notion.so', 'path': '/',
+                            'secure': True, 'httpOnly': True, 'sameSite': 'Lax'
+                        })
+                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.")
+            else:
+                 logging.error("Error: Account cookie is empty for background task.")
+                 raise ValueError("Server configuration error: Notion cookie not set for background task.")
+
+            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
+                del js_fetch_headers['cookie']
+
+
+            javascript_code = """
+            async (args) => {
+                const { apiUrl, headers, body } = args;
+                try {
+                    const response = await fetch(apiUrl, {
+                        method: 'POST',
+                        headers: headers,
+                        body: body
+                    });
+                    if (!response.ok) {
+                        const errorText = await response.text();
+                        console.error('JS Fetch error:', response.status, errorText);
+                        await window.signalStreamEnd();
+                        return { success: false, status: response.status, error: errorText };
+                    }
+                    if (!response.body) {
+                         console.error('JS Response body is null');
+                         await window.signalStreamEnd();
+                         return { success: false, error: 'Response body is null' };
+                    }
+                    const reader = response.body.getReader();
+                    const decoder = new TextDecoder();
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done) break;
+                        await window.sendChunkToPython(decoder.decode(value, { stream: true }));
+                    }
+                    await window.signalStreamEnd();
+                    return { success: true };
+                } catch (error) {
+                    console.error('JS Exception during fetch:', error);
+                    await window.signalStreamEnd();
+                    return { success: false, error: error.toString() };
+                }
+            }
+            """
+            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.")
+
+# --- Main Generator Called by Endpoint ---
+async def stream_notion_response(notion_request_body: NotionRequestBody, account: NotionAccount):
+    """Creates background task for Playwright and yields results from queue."""
+    chunk_queue = asyncio.Queue()
+    playwright_task = None
+    
+    # These should be defined once per request stream
+    chunk_id = f"chatcmpl-{uuid.uuid4()}"
+    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',
+        'content-type': 'application/json',
+        'notion-audit-log-platform': 'web',
+        'notion-client-version': '23.13.0.3668',
+        'origin': 'https://www.notion.so',
+        'priority': 'u=1, i',
+        'referer': 'https://www.notion.so/chat',
+        '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"',
+        'sec-fetch-dest': 'empty',
+        'sec-fetch-mode': 'cors',
+        '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,
+                notion_request_body,
+                headers_template,
+                NOTION_API_URL,         # Global constant
+                account                 # Pass the selected 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
+            while '\n' in accumulated_line:
+                line, accumulated_line = accumulated_line.split('\n', 1)
+                if not line.strip():
+                    continue
+                try:
+                    data = json.loads(line)
+                    if data.get("type") == "markdown-chat" and isinstance(data.get("value"), str):
+                        content_chunk = data["value"]
+                        if content_chunk:
+                            sse_chunk = ChatCompletionChunk(
+                                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.")
+                except json.JSONDecodeError:
+                    logging.warning(f"Warning: Main generator could not decode JSON line: {line}")
+                except Exception as e:
+                    logging.error(f"Error processing line in main generator: {line} - {e}")
+        
+        # Process any final accumulated data after None sentinel
+        if accumulated_line.strip():
+             try:
+                 data = json.loads(accumulated_line)
+                 if data.get("type") == "markdown-chat" and isinstance(data.get("value"), str):
+                     content_chunk = data["value"]
+                     if content_chunk:
+                         sse_chunk = ChatCompletionChunk(
+                             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}")
+             except Exception as e:
+                 logging.error(f"Error processing final line in main generator: {accumulated_line} - {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}")
+        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}")
+        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}")
+
+
+# --- API Endpoint ---
+
+@app.get("/v1/models", response_model=ModelList)
+async def list_models(authenticated: bool = Depends(authenticate)):
+    """
+    Endpoint to list available Notion models, mimicking OpenAI's /v1/models.
+    """
+    available_models = [
+        "openai-gpt-4.1",
+        "anthropic-opus-4",
+        "anthropic-sonnet-4"
+    ]
+    model_list = [
+        Model(id=model_id, owned_by="notion") # created uses default_factory
+        for model_id in available_models
+    ]
+    return ModelList(data=model_list)
+
+@app.post("/v1/chat/completions")
+async def chat_completions(request_data: ChatCompletionRequest, request: Request, authenticated: bool = Depends(authenticate)):
+    """
+    Endpoint to mimic OpenAI's chat completions, proxying to Notion.
+    It uses round-robin to select a healthy Notion account for each request.
+    """
+    account = get_next_account() # Select a healthy account
+
+    notion_request_body = build_notion_request(request_data, account)
+
+    if request_data.stream:
+        # Call the Playwright generator, passing the selected account
+        return StreamingResponse(
+            stream_notion_response(notion_request_body, account),
+            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.
+        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):
+                 if line.startswith("data: ") and "[DONE]" not in line:
+                    try:
+                        data_json = line[len("data: "):].strip()
+                        if data_json:
+                            chunk_data = json.loads(data_json)
+                            if chunk_data.get("choices"):
+                                delta = chunk_data["choices"][0].get("delta", {})
+                                content = delta.get("content")
+                                if content:
+                                    full_response_content += content
+                                finish_reason = chunk_data["choices"][0].get("finish_reason")
+                                if finish_reason:
+                                    final_finish_reason = finish_reason
+                    except json.JSONDecodeError:
+                        print(f"Warning: Could not decode JSON line in non-streaming mode: {line}")
+
+            # Construct the final OpenAI-compatible non-streaming response
+            return {
+                "id": chunk_id,
+                "object": "chat.completion",
+                "created": created_time,
+                "model": request_data.model, # Return the model requested by the client
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": full_response_content,
+                        },
+                        "finish_reason": final_finish_reason or "stop", # Default to stop if not explicitly set
+                    }
+                ],
+                "usage": { # Note: Token usage is not available from Notion
+                    "prompt_tokens": None,
+                    "completion_tokens": None,
+                    "total_tokens": None,
+                },
+            }
+        except HTTPException as e:
+             # Re-raise HTTP exceptions from the streaming function
+             raise e
+        except Exception as e:
+            print(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")
+    print("Ensure NOTION_COOKIES is set in your .env file or environment, separated by '|'.")
+    uvicorn.run(app, host="127.0.0.1", port=7860)

models.py

@@ -0,0 +1,100 @@
+import time
+import uuid
+from pydantic import BaseModel, Field
+from typing import List, Optional, Dict, Any, Literal, Union
+
+# --- Models Moved from main.py ---
+
+# Input Models (OpenAI-like)
+class ChatMessage(BaseModel):
+    id: uuid.UUID = Field(default_factory=uuid.uuid4)
+    role: Literal["system", "user", "assistant"]
+    content: Union[str, List[Dict[str, Any]]]
+    userId: Optional[str] = None # Added for user messages
+    createdAt: Optional[str] = None # Added for timestamping
+    traceId: Optional[str] = None # Added for assistant messages
+
+class ChatCompletionRequest(BaseModel):
+    messages: List[ChatMessage]
+    model: str = "notion-proxy" # Model name can be passed, but we map to Notion's model
+    stream: bool = False
+    # Add other potential OpenAI params if needed, though they might not map directly
+    # max_tokens: Optional[int] = None
+    # temperature: Optional[float] = None
+    # space_id and thread_id are now handled globally via environment variables
+    notion_model: str = "anthropic-opus-4" # Default Notion model, can be overridden
+
+
+# Notion Models
+class NotionTranscriptConfigValue(BaseModel):
+    type: str = "markdown-chat"
+    model: str # e.g., "anthropic-opus-4"
+
+class NotionTranscriptContextValue(BaseModel):
+    userId: str
+    spaceId: str
+    surface: str = "home_module"
+    timezone: str = "America/Los_Angeles"
+    userName: str
+    spaceName: str
+    spaceViewId: str
+    currentDatetime: str
+
+class NotionTranscriptItem(BaseModel):
+    id: uuid.UUID = Field(default_factory=uuid.uuid4)
+    type: Literal["config", "user", "markdown-chat", "agent-integration", "context"]
+    value: Optional[Union[List[List[str]], str, NotionTranscriptConfigValue, NotionTranscriptContextValue]] = None
+    userId: Optional[str] = None # Added for user messages in Notion transcript
+    createdAt: Optional[str] = None # Added for timestamping in Notion transcript
+    traceId: Optional[str] = None # Added for assistant messages in Notion transcript
+
+class NotionDebugOverrides(BaseModel):
+    cachedInferences: Dict = Field(default_factory=dict)
+    annotationInferences: Dict = Field(default_factory=dict)
+    emitInferences: bool = False
+
+class NotionRequestBody(BaseModel):
+    traceId: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    spaceId: str
+    transcript: List[NotionTranscriptItem]
+    # threadId is removed, createThread will be set to true
+    createThread: bool = True
+    debugOverrides: NotionDebugOverrides = Field(default_factory=NotionDebugOverrides)
+    generateTitle: bool = False
+    saveAllThreadOperations: bool = True
+
+    class Config:
+        # Ensure UUIDs are serialized as strings in the final JSON request
+        json_encoders = {
+            uuid.UUID: str
+        }
+
+
+# Output Models (OpenAI SSE)
+class ChoiceDelta(BaseModel):
+    content: Optional[str] = None
+
+class Choice(BaseModel):
+    index: int = 0
+    delta: ChoiceDelta
+    finish_reason: Optional[Literal["stop", "length"]] = None
+
+class ChatCompletionChunk(BaseModel):
+    id: str = Field(default_factory=lambda: f"chatcmpl-{uuid.uuid4()}")
+    object: str = "chat.completion.chunk"
+    created: int = Field(default_factory=lambda: int(time.time()))
+    model: str = "notion-proxy" # Or could reflect the underlying Notion model
+    choices: List[Choice]
+
+
+# --- Models for /v1/models Endpoint ---
+
+class Model(BaseModel):
+    id: str
+    object: str = "model"
+    created: int = Field(default_factory=lambda: int(time.time()))
+    owned_by: str = "notion" # Or specify based on actual model origin if needed
+
+class ModelList(BaseModel):
+    object: str = "list"
+    data: List[Model]

requirements.txt

@@ -0,0 +1,6 @@
+fastapi
+uvicorn[standard]
+httpx
+pydantic
+python-dotenv
+playwright