Upload 9 files (#1)

- Upload 9 files (98483f7b2150f42adc1600d9129cd29aa2e7668f)


Co-authored-by: Akiyama <[email protected]>

.env.example

@@ -0,0 +1,4 @@
+NOTION_COOKIE=YOUR_NOTION_COOKIE
+NOTION_SPACE_ID=YOUR_NOTION_SPACE_ID
+NOTION_ACTIVE_USER_HEADER=YOUR_NOTION_ACTIVE_USER_HEADER
+PROXY_AUTH_TOKEN=123321

Dockerfile

@@ -1,28 +1,27 @@
-# 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
-
-# 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
+# Use an official Python runtime as a parent image
+FROM python:3.13-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
+
+# Copy the current directory contents into the container at /app
+COPY main.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"]

README.md

@@ -17,8 +17,8 @@ This project provides a FastAPI application that acts as a bridge between OpenAI
 
 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`).
+*   `NOTION_COOKIE`: Your Notion `token_v2` 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 your Notion workspace. You can usually find this in the URL when browsing your Notion workspace (it's the part after your domain and before the first page ID, often a UUID).
 *   `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.
 
@@ -29,18 +29,17 @@ The application requires the following environment variables to be set:
     ```bash
     pip install -r requirements.txt
     ```
-3.  Create a `.env` file in the project root with your `NOTION_COOKIE`:
+3.  Create a `.env` file in the project root with your `NOTION_COOKIE` and `NOTION_SPACE_ID`:
     ```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
     ```
 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.
+    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.
 
 ## Running with Docker Compose (Recommended for Local Dev)
 
@@ -54,7 +53,7 @@ This method uses the `docker-compose.yml` file for a streamlined local developme
     ```
     *   `--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.
+4.  The application will be accessible locally at `http://localhost:8139`.
 
 To stop the service, run:
 ```bash
@@ -70,7 +69,7 @@ This method involves building and running the Docker container manually, passing
     docker build -t notion-api-bridge .
     ```
 2.  **Run the Docker container:**
-    Replace `"your_cookie_value"` with your actual Notion cookie.
+    Replace `"your_cookie_value"` and `"your_space_id"` with your actual Notion credentials.
     ```bash
     docker run -p 7860:7860 \
       -e NOTION_COOKIE="your_cookie_value" \
@@ -79,7 +78,7 @@ This method involves building and running the Docker container manually, passing
       # -e NOTION_ACTIVE_USER_HEADER="your_user_id" \ # Optional: Set the active user header
       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.
+    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.
 
 ## Deploying to Hugging Face Spaces
 
@@ -89,12 +88,12 @@ This application is designed to be easily deployed as a Docker Space on Hugging
 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.
+    *   `NOTION_SPACE_ID`: Paste your Notion Space ID.
     *   `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.
     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.
+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`).
 
     **Example using `curl` (replace `your_token` and URL):**
     ```bash

docker-compose.yml

@@ -3,6 +3,6 @@ services:
   notion-bridge:
     build: .
     ports:
-      - "8139:7860" # Map host port 8139 to container port 7860
+      - "7860:7860"
     env_file:
       - .env

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/

main.py

@@ -1,373 +1,835 @@
-import os
-import uuid
-import json
-import time
-import random
-import httpx
-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 models import (
-    ChatMessage, ChatCompletionRequest, NotionTranscriptConfigValue,
-    NotionTranscriptContextValue, NotionTranscriptItem, NotionDebugOverrides,
-    NotionRequestBody, ChoiceDelta, Choice, ChatCompletionChunk, Model, ModelList
-)
-
-# Load environment variables from .env file
-load_dotenv()
-
-# --- Configuration ---
-NOTION_API_URL = "https://www.notion.so/api/v3/runInferenceTranscript"
-# IMPORTANT: Load the Notion cookie securely from environment variables
-NOTION_COOKIE = os.getenv("NOTION_COOKIE")
-
-NOTION_SPACE_ID = os.getenv("NOTION_SPACE_ID")
-if not NOTION_COOKIE:
-    print("Error: NOTION_COOKIE environment variable not set.")
-    # Consider raising HTTPException or exiting in a real app
-if not NOTION_SPACE_ID:
-    print("Warning: NOTION_SPACE_ID environment variable not set. Using a default UUID.")
-    # Using a default might not be ideal, depends on Notion's behavior
-    # Consider raising an error instead: raise ValueError("NOTION_SPACE_ID not set")
-    NOTION_SPACE_ID = str(uuid.uuid4()) # Default or raise error
-
-# --- 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
-
-# --- FastAPI App ---
-app = FastAPI()
-
-# --- Helper Functions ---
-
-def build_notion_request(request_data: ChatCompletionRequest) -> NotionRequestBody:
-    """Transforms OpenAI-style messages to Notion transcript format, adding userId and createdAt."""
-    
-    # --- Timestamp and User ID Logic ---
-    user_id = os.getenv("NOTION_ACTIVE_USER_HEADER")
-    # 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 env or empty string
-                spaceId=NOTION_SPACE_ID,
-                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 globally configured spaceId, set createThread=True
-    return NotionRequestBody(
-        spaceId=NOTION_SPACE_ID, # From environment variable
-        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
-    )
-
-async def stream_notion_response(notion_request_body: NotionRequestBody):
-    """Streams the request to Notion and yields OpenAI-compatible SSE chunks."""
-    headers = {
-        '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', # Consider making this configurable
-        'origin': 'https://www.notion.so',
-        'priority': 'u=1, i',
-        # Referer might be optional or need adjustment. Removing threadId part.
-        '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': NOTION_COOKIE, # Loaded from .env
-        'x-notion-space-id': NOTION_SPACE_ID # Added space ID header
-    }
-
-    # Conditionally add the active user header
-    notion_active_user = os.getenv("NOTION_ACTIVE_USER_HEADER")
-    if notion_active_user: # Checks for None and empty string implicitly
-        headers['x-notion-active-user-header'] = notion_active_user
-
-    chunk_id = f"chatcmpl-{uuid.uuid4()}"
-    created_time = int(time.time())
-
-    try:
-        async with httpx.AsyncClient(timeout=None) as client: # No timeout for streaming
-            # Explicitly serialize using .json() to respect Pydantic Config (like json_encoders for UUID)
-            request_body_json = notion_request_body.json()
-            async with client.stream("POST", NOTION_API_URL, content=request_body_json, headers=headers) as response:
-                if response.status_code != 200:
-                    error_content = await response.aread()
-                    print(f"Error from Notion API: {response.status_code}")
-                    print(f"Response: {error_content.decode()}")
-                    # Yield an error message in SSE format? Or just raise exception?
-                    # For now, raise internal server error in the endpoint
-                    raise HTTPException(status_code=response.status_code, detail=f"Notion API Error: {error_content.decode()}")
-
-                async for line in response.aiter_lines():
-                    if not line.strip():
-                        continue
-                    try:
-                        data = json.loads(line)
-                        # Check if it's the type of message containing text chunks
-                        if data.get("type") == "markdown-chat" and isinstance(data.get("value"), str):
-                            content_chunk = data["value"]
-                            if content_chunk: # Only send if there's content
-                                chunk = ChatCompletionChunk(
-                                    id=chunk_id,
-                                    created=created_time,
-                                    choices=[Choice(delta=ChoiceDelta(content=content_chunk))]
-                                )
-                                yield f"data: {chunk.json()}\n\n"
-                        # Add logic here to detect the end of the stream if Notion has a specific marker
-                        # For now, we assume markdown-chat stops when the main content is done.
-                        # If we see a recordMap, it's definitely past the text stream.
-                        elif "recordMap" in data:
-                             print("Detected recordMap, stopping stream.")
-                             break # Stop processing after recordMap
-
-                    except json.JSONDecodeError:
-                        print(f"Warning: Could not decode JSON line: {line}")
-                    except Exception as e:
-                        print(f"Error processing line: {line} - {e}")
-                        # Decide if we should continue or stop
-
-        # Send the final chunk indicating stop
-        final_chunk = ChatCompletionChunk(
-            id=chunk_id,
-            created=created_time,
-            choices=[Choice(delta=ChoiceDelta(), finish_reason="stop")]
-        )
-        yield f"data: {final_chunk.json()}\n\n"
-        yield "data: [DONE]\n\n"
-
-    except httpx.RequestError as e:
-        print(f"HTTPX Request Error: {e}")
-        # Yield an error message or handle in the endpoint
-        # For now, let the endpoint handle it
-        raise HTTPException(status_code=500, detail=f"Error connecting to Notion API: {e}")
-    except Exception as e:
-        print(f"Unexpected error during streaming: {e}")
-        # Yield an error message or handle in the endpoint
-        raise HTTPException(status_code=500, detail=f"Internal server error during streaming: {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.
-    """
-    if not NOTION_COOKIE:
-         raise HTTPException(status_code=500, detail="Server configuration error: Notion cookie not set.")
-
-    notion_request_body = build_notion_request(request_data)
-
-    if request_data.stream:
-        return StreamingResponse(
-            stream_notion_response(notion_request_body),
-            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())
-
-        try:
-            async for line in stream_notion_response(notion_request_body):
-                 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_COOKIE is set in your .env file or environment.")
-    uvicorn.run(app, host="127.0.0.1", port=7860)
+import os
+import uuid
+import json
+import time
+import asyncio
+import random
+import threading
+from curl_cffi.requests import AsyncSession
+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
+from pydantic import BaseModel, Field
+from typing import List, Optional, Dict, Any, Literal, Union
+from contextlib import asynccontextmanager
+
+# Load environment variables from .env file
+load_dotenv()
+
+# --- 并发请求配置 ---
+CONCURRENT_REQUESTS = 1  # 可自定义并发请求数量
+
+# --- 重试配置 ---
+MAX_RETRIES = 3
+RETRY_DELAY = 1  # 秒
+
+# --- Models (Integrated from models.py) ---
+
+# Input Models (OpenAI-like)
+class ChatMessage(BaseModel):
+    role: Literal["system", "user", "assistant"]
+    content: str
+
+class ChatCompletionRequest(BaseModel):
+    messages: List[ChatMessage]
+    model: str = "notion-proxy"
+    stream: bool = False
+    notion_model: str = "anthropic-opus-4" 
+
+
+# Notion Models
+class NotionTranscriptConfigValue(BaseModel):
+    type: str = "markdown-chat"
+    model: str # e.g., "anthropic-opus-4"
+
+class NotionTranscriptItem(BaseModel):
+    type: Literal["config", "user", "markdown-chat"]
+    value: Union[List[List[str]], str, NotionTranscriptConfigValue]
+
+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
+
+
+# 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]
+
+# --- Configuration ---
+NOTION_API_URL = "https://www.notion.so/api/v3/runInferenceTranscript"
+# IMPORTANT: Load the Notion cookie securely from environment variables
+NOTION_COOKIE = os.getenv("NOTION_COOKIE")
+
+NOTION_SPACE_ID = os.getenv("NOTION_SPACE_ID")
+if not NOTION_COOKIE:
+    print("Error: NOTION_COOKIE environment variable not set.")
+    # Consider raising HTTPException or exiting in a real app
+if not NOTION_SPACE_ID:
+    print("Warning: NOTION_SPACE_ID environment variable not set. Using a default UUID.")
+    # Using a default might not be ideal, depends on Notion's behavior
+    # Consider raising an error instead: raise ValueError("NOTION_SPACE_ID not set")
+    NOTION_SPACE_ID = str(uuid.uuid4()) # Default or raise error
+
+# --- Cookie Management ---
+browser_cookies = ""
+cookie_lock = threading.Lock()
+last_cookie_update = 0
+COOKIE_UPDATE_INTERVAL = 30 * 60  # 30 minutes in seconds
+
+async def get_browser_cookies():
+    """获取Notion网站的浏览器cookie"""
+    global browser_cookies, last_cookie_update
+    
+    try:
+        print("正在获取Notion浏览器cookie...")
+        async with AsyncSession(impersonate="chrome136") as session:
+            response = await session.get("https://www.notion.so")
+            
+            if response.status_code == 200:
+                # 获取所有cookie
+                cookies = response.cookies
+                notion_so_cookies = []
+                
+                # 处理CookieConflict问题，只获取.notion.so域名的cookie
+                try:
+                    # 尝试通过域名过滤来避免冲突
+                    if hasattr(cookies, 'get_dict'):
+                        # 使用get_dict方法并指定域名
+                        notion_so_dict = cookies.get_dict(domain='.notion.so')
+                        for name, value in notion_so_dict.items():
+                            notion_so_cookies.append(f"{name}={value}")
+                    elif hasattr(cookies, 'jar'):
+                        # 如果cookies有jar属性，遍历并过滤域名
+                        for cookie in cookies.jar:
+                            if hasattr(cookie, 'domain') and cookie.domain:
+                                if '.notion.so' in cookie.domain and '.notion.com' not in cookie.domain:
+                                    notion_so_cookies.append(f"{cookie.name}={cookie.value}")
+                    else:
+                        # 尝试手动构建cookie字符串，避免冲突
+                        # 直接从响应头中提取Set-Cookie信息
+                        set_cookie_headers = response.headers.get_list('Set-Cookie') if hasattr(response.headers, 'get_list') else []
+                        if not set_cookie_headers and 'Set-Cookie' in response.headers:
+                            set_cookie_headers = [response.headers['Set-Cookie']]
+                        
+                        for cookie_header in set_cookie_headers:
+                            if 'domain=.notion.so' in cookie_header or ('notion.so' in cookie_header and 'notion.com' not in cookie_header):
+                                # 提取cookie名称和值
+                                cookie_parts = cookie_header.split(';')[0].strip()
+                                if '=' in cookie_parts:
+                                    notion_so_cookies.append(cookie_parts)
+                        
+                        # 如果还是没有获取到，尝试使用requests-like的方式
+                        if not notion_so_cookies and hasattr(response, 'cookies'):
+                            try:
+                                # 遍历所有cookie，手动过滤
+                                for cookie in response.cookies:
+                                    if hasattr(cookie, 'domain') and cookie.domain and '.notion.so' in cookie.domain:
+                                        notion_so_cookies.append(f"{cookie.name}={cookie.value}")
+                            except Exception as inner_e:
+                                print(f"内部cookie处理错误: {inner_e}")
+                
+                except Exception as cookie_error:
+                    print(f"处理cookie时出现错误: {cookie_error}")
+                    # 如果所有方法都失败，尝试从session获取
+                    if hasattr(session, 'cookies'):
+                        try:
+                            for name, value in session.cookies.items():
+                                notion_so_cookies.append(f"{name}={value}")
+                        except:
+                            pass
+                
+                # 添加环境变量中的cookie，加上token_v2前缀
+                if NOTION_COOKIE:
+                    notion_so_cookies.append(f"token_v2={NOTION_COOKIE}")
+                
+                # 如果没有获取到任何cookie，至少使用环境变量的
+                if not notion_so_cookies and NOTION_COOKIE:
+                    notion_so_cookies = [f"token_v2={NOTION_COOKIE}"]
+                
+                with cookie_lock:
+                    browser_cookies = "; ".join(notion_so_cookies)
+                    last_cookie_update = time.time()
+                
+                # 提取cookie名称用于日志显示
+                cookie_names = []
+                for cookie_str in notion_so_cookies:
+                    if '=' in cookie_str:
+                        name = cookie_str.split('=')[0]
+                        cookie_names.append(name)
+                
+                print(f"成功获取到 {len(notion_so_cookies)} 个cookie")
+                print(f"Cookie名称列表: {', '.join(cookie_names)}")
+                return True
+            else:
+                print(f"获取cookie失败，HTTP状态码: {response.status_code}")
+                return False
+                
+    except Exception as e:
+        print(f"获取browser cookie时出错: {e}")
+        print(f"错误详情: {type(e).__name__}: {str(e)}")
+        
+        # 如果完全失败，至少使用环境变量的cookie
+        if NOTION_COOKIE:
+            with cookie_lock:
+                browser_cookies = f"token_v2={NOTION_COOKIE}"
+                last_cookie_update = time.time()
+            print("使用环境变量cookie作为备用")
+            return True
+        return False
+
+def should_update_cookies():
+    """检查是否需要更新cookie"""
+    return time.time() - last_cookie_update > COOKIE_UPDATE_INTERVAL
+
+async def ensure_cookies_available():
+    """确保cookie可用，如果需要则更新"""
+    global browser_cookies
+    
+    if not browser_cookies or should_update_cookies():
+        success = await get_browser_cookies()
+        if not success and not browser_cookies:
+            # 如果获取失败且没有备用cookie，使用环境变量的cookie
+            if NOTION_COOKIE:
+                with cookie_lock:
+                    browser_cookies = f"token_v2={NOTION_COOKIE}"
+                print("使用环境变量cookie作为备用")
+            else:
+                raise HTTPException(status_code=500, detail="无法获取Notion cookie")
+
+def start_cookie_updater():
+    """启动cookie定时更新器"""
+    def cookie_updater():
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        
+        while True:
+            try:
+                if should_update_cookies():
+                    print("开始定时更新cookie...")
+                    loop.run_until_complete(get_browser_cookies())
+                time.sleep(60)  # 每分钟检查一次
+            except Exception as e:
+                print(f"定时更新cookie时出错: {e}")
+                time.sleep(60)
+    
+    thread = threading.Thread(target=cookie_updater, daemon=True)
+    thread.start()
+    print("cookie定时更新器已启动")
+
+# --- 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
+
+# --- Lifespan Event Handler ---
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """应用生命周期管理"""
+    # 启动时的初始化
+    print("正在初始化Notion浏览器cookie...")
+    await get_browser_cookies()
+    # 启动cookie定时更新器
+    start_cookie_updater()
+    yield
+    # 关闭时的清理（如果需要）
+
+# --- FastAPI App ---
+app = FastAPI(lifespan=lifespan)
+
+# --- Helper Functions ---
+
+def build_notion_request(request_data: ChatCompletionRequest) -> NotionRequestBody:
+    """Transforms OpenAI-style messages to Notion transcript format."""
+    transcript = [
+        NotionTranscriptItem(
+            type="config",
+            value=NotionTranscriptConfigValue(model=request_data.notion_model)
+        )
+    ]
+    for message in request_data.messages:
+        # Map 'assistant' role to 'markdown-chat', all others to 'user'
+        if message.role == "assistant":
+            # Notion uses "markdown-chat" for assistant replies in the transcript history
+            transcript.append(NotionTranscriptItem(type="markdown-chat", value=message.content))
+        else:
+            # Map user, system, and any other potential roles to 'user'
+            transcript.append(NotionTranscriptItem(type="user", value=[[message.content]]))
+
+    # Use globally configured spaceId, set createThread=True
+    return NotionRequestBody(
+        spaceId=NOTION_SPACE_ID, # From environment variable
+        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
+    )
+
+
+async def check_first_response_line(session: AsyncSession, notion_request_body: NotionRequestBody, headers: dict, request_id: int):
+    """检查响应的第一行，判断是否为500错误"""
+    try:
+        # 当并发请求数大于1时，添加随机延迟以避免同时到达
+        if CONCURRENT_REQUESTS > 1:
+            delay = random.uniform(0, 1.0)
+            print(f"并发请求 {request_id} 延迟 {delay:.2f}秒")
+            await asyncio.sleep(delay)
+        
+        # 为每个并发请求创建独立的请求体，生成新的traceId
+        request_body_copy = notion_request_body.model_copy()
+        request_body_copy.traceId = str(uuid.uuid4())
+        
+        response = await session.post(
+            NOTION_API_URL,
+            json=request_body_copy.model_dump(),
+            headers=headers,
+            stream=True
+        )
+        
+        if response.status_code != 200:
+            return None, response, f"HTTP {response.status_code}"
+        
+        # 读取第一行来检查是否是错误
+        buffer = ""
+        async for chunk in response.aiter_content():
+            if isinstance(chunk, bytes):
+                chunk = chunk.decode('utf-8')
+            buffer += chunk
+            
+            # 尝试解析第一个完整的JSON行
+            lines = buffer.split('\n')
+            for line in lines:
+                line = line.strip()
+                if line:
+                    try:
+                        data = json.loads(line)
+                        if (data.get("type") == "error" and
+                            data.get("message") and
+                            "error code 500" in data.get("message", "")):
+                            print(f"并发请求 {request_id} 检测到500错误: {data}")
+                            return None, response, "500 error"
+                        else:
+                            # 正常响应，返回response和已读取的buffer
+                            print(f"并发请求 {request_id} 响应正常")
+                            return (response, buffer), None, None
+                    except json.JSONDecodeError:
+                        continue
+            
+        return None, response, "No valid response"
+    except Exception as e:
+        print(f"并发请求 {request_id} 发生异常: {e}")
+        return None, None, str(e)
+
+async def stream_notion_response_single(session: AsyncSession, response, initial_buffer: str, chunk_id: str, created_time: int):
+    """处理单个响应的流式输出"""
+    buffer = initial_buffer
+    
+    # 首先处理已经读取的buffer中的内容
+    lines = buffer.split('\n')
+    buffer = lines[-1]
+    
+    for line in lines[:-1]:
+        line = line.strip()
+        if not line:
+            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:
+                    chunk_obj = ChatCompletionChunk(
+                        id=chunk_id,
+                        created=created_time,
+                        choices=[Choice(delta=ChoiceDelta(content=content_chunk))]
+                    )
+                    yield f"data: {chunk_obj.model_dump_json()}\n\n"
+            elif "recordMap" in data:
+                print("Detected recordMap, stopping stream.")
+                # 继续处理剩余的buffer
+                if buffer.strip():
+                    try:
+                        last_data = json.loads(buffer.strip())
+                        if last_data.get("type") == "markdown-chat" and isinstance(last_data.get("value"), str):
+                            if last_data["value"]:
+                                last_chunk = ChatCompletionChunk(
+                                    id=chunk_id,
+                                    created=created_time,
+                                    choices=[Choice(delta=ChoiceDelta(content=last_data["value"]))]
+                                )
+                                yield f"data: {last_chunk.model_dump_json()}\n\n"
+                    except:
+                        pass
+                return
+        except json.JSONDecodeError as e:
+            print(f"Warning: Could not decode JSON line: {line[:100]}... Error: {str(e)}")
+        except Exception as e:
+            print(f"Error processing line: {str(e)}")
+    
+    # 继续读取剩余的响应
+    async for chunk in response.aiter_content():
+        if isinstance(chunk, bytes):
+            chunk = chunk.decode('utf-8')
+        
+        buffer += chunk
+        
+        lines = buffer.split('\n')
+        buffer = lines[-1]
+        
+        for line in lines[:-1]:
+            line = line.strip()
+            if not line:
+                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:
+                        chunk_obj = ChatCompletionChunk(
+                            id=chunk_id,
+                            created=created_time,
+                            choices=[Choice(delta=ChoiceDelta(content=content_chunk))]
+                        )
+                        yield f"data: {chunk_obj.model_dump_json()}\n\n"
+                elif "recordMap" in data:
+                    print("Detected recordMap, stopping stream.")
+                    if buffer.strip():
+                        try:
+                            last_data = json.loads(buffer.strip())
+                            if last_data.get("type") == "markdown-chat" and isinstance(last_data.get("value"), str):
+                                if last_data["value"]:
+                                    last_chunk = ChatCompletionChunk(
+                                        id=chunk_id,
+                                        created=created_time,
+                                        choices=[Choice(delta=ChoiceDelta(content=last_data["value"]))]
+                                    )
+                                    yield f"data: {last_chunk.model_dump_json()}\n\n"
+                        except:
+                            pass
+                    return
+            except json.JSONDecodeError as e:
+                print(f"Warning: Could not decode JSON line: {line[:100]}... Error: {str(e)}")
+            except Exception as e:
+                print(f"Error processing line: {str(e)}")
+
+async def stream_notion_response(notion_request_body: NotionRequestBody):
+    """Streams the request to Notion and yields OpenAI-compatible SSE chunks."""
+    
+    # 确保cookie可用
+    await ensure_cookies_available()
+    
+    with cookie_lock:
+        current_cookies = browser_cookies
+    
+    headers = {
+        'accept': 'application/x-ndjson',
+        'accept-encoding': 'gzip, deflate, br, zstd',
+        'accept-language': 'en-US,zh;q=0.9',
+        'content-type': 'application/json',
+        'dnt': '1',
+        'notion-audit-log-platform': 'web',
+        'notion-client-version': '23.13.0.3661',
+        'origin': 'https://www.notion.so',
+        'referer': 'https://www.notion.so/',
+        'priority': 'u=1, i',
+        'sec-ch-ua-mobile': '?0',
+        'sec-ch-ua-platform': '"Windows"',
+        'sec-fetch-dest': 'empty',
+        'sec-fetch-mode': 'cors',
+        'sec-fetch-site': 'same-origin',
+        'cookie': current_cookies,
+        'x-notion-space-id': NOTION_SPACE_ID
+    }
+    
+    # Conditionally add the active user header
+    notion_active_user = os.getenv("NOTION_ACTIVE_USER_HEADER")
+    if notion_active_user:  # Checks for None and empty string implicitly
+        headers['x-notion-active-user-header'] = notion_active_user
+
+    chunk_id = f"chatcmpl-{uuid.uuid4()}"
+    created_time = int(time.time())
+    
+    # 使用全局重试配置
+    max_retries = MAX_RETRIES
+    retry_delay = RETRY_DELAY
+    
+    # 首先尝试并发请求
+    print(f"同时发起 {CONCURRENT_REQUESTS} 个并发请求...")
+    async with AsyncSession(impersonate="chrome136") as session:
+        # 同时创建并发任务（每个都是独立的异步任务）
+        tasks = []
+        for i in range(CONCURRENT_REQUESTS):
+            task = asyncio.create_task(
+                check_first_response_line(session, notion_request_body, headers, i + 1)
+            )
+            tasks.append(task)
+        
+        # 等待所有任务完成或找到第一个成功的响应
+        successful_response = None
+        failed_count = 0
+        completed_tasks = set()
+        
+        while len(completed_tasks) < CONCURRENT_REQUESTS and not successful_response:
+            # 等待任意一个任务完成
+            done, pending = await asyncio.wait(
+                [t for t in tasks if t not in completed_tasks],
+                return_when=asyncio.FIRST_COMPLETED
+            )
+            
+            for task in done:
+                completed_tasks.add(task)
+                result, response, error = await task
+                if result:
+                    # 找到成功的响应，立即使用
+                    successful_response = result
+                    print(f"找到成功的并发响应，立即使用")
+                    # 取消其他还在运行的任务
+                    for t in tasks:
+                        if t not in completed_tasks:
+                            t.cancel()
+                    break
+                else:
+                    # 记录失败
+                    failed_count += 1
+                    if error:
+                        print(f"并发请求失败: {error}")
+        
+        # 如果有成功的响应，使用它进行流式传输
+        if successful_response:
+            response, initial_buffer = successful_response
+            print("使用成功的并发响应进行流式传输")
+            
+            # 流式输出响应
+            async for data in stream_notion_response_single(session, response, initial_buffer, chunk_id, created_time):
+                yield data
+            
+            # Send the final chunk indicating stop
+            final_chunk = ChatCompletionChunk(
+                id=chunk_id,
+                created=created_time,
+                choices=[Choice(delta=ChoiceDelta(), finish_reason="stop")]
+            )
+            yield f"data: {final_chunk.model_dump_json()}\n\n"
+            yield "data: [DONE]\n\n"
+            return
+        
+        # 只有当所有并发请求都失败时，才进入重试流程
+        print(f"所有 {CONCURRENT_REQUESTS} 个并发请求都失败，开始单请求重试流程...")
+    
+    # 进入原有的重试逻辑（不使用并发）
+    for attempt in range(max_retries):
+        try:
+            # Using curl_cffi with chrome136 impersonation for better anti-bot bypass
+            async with AsyncSession(impersonate="chrome136") as session:
+                # Stream the response
+                response = await session.post(
+                    NOTION_API_URL,
+                    json=notion_request_body.model_dump(),
+                    headers=headers,
+                    stream=True
+                )
+                
+                if response.status_code != 200:
+                    error_content = await response.atext()
+                    print(f"Error from Notion API: {response.status_code}")
+                    print(f"Response: {error_content}")
+                    raise HTTPException(status_code=response.status_code, detail=f"Notion API Error: {error_content}")
+
+                # Process streaming response
+                # curl_cffi streaming works differently - we need to read the content in chunks
+                buffer = ""
+                first_line_checked = False
+                is_error_response = False
+                
+                async for chunk in response.aiter_content():
+                    # Decode chunk if it's bytes
+                    if isinstance(chunk, bytes):
+                        chunk = chunk.decode('utf-8')
+                    
+                    buffer += chunk
+                    
+                    # Split by newlines and process complete lines
+                    lines = buffer.split('\n')
+                    # Keep the last incomplete line in the buffer
+                    buffer = lines[-1]
+                    
+                    for line in lines[:-1]:
+                        line = line.strip()
+                        if not line:
+                            continue
+                        
+                        try:
+                            data = json.loads(line)
+                            
+                            # 检查第一行是否是500错误响应
+                            if not first_line_checked:
+                                first_line_checked = True
+                                if (data.get("type") == "error" and
+                                    data.get("message") and
+                                    "error code 500" in data.get("message", "")):
+                                    print(f"检测到Notion API 500错误 (重试 {attempt + 1}/{max_retries}): {data}")
+                                    is_error_response = True
+                                    break
+                            
+                            # 如果不是错误响应，实时流式转发
+                            # Check if it's the type of message containing text chunks
+                            if data.get("type") == "markdown-chat" and isinstance(data.get("value"), str):
+                                content_chunk = data["value"]
+                                if content_chunk:  # Only send if there's content
+                                    chunk_obj = ChatCompletionChunk(
+                                        id=chunk_id,
+                                        created=created_time,
+                                        choices=[Choice(delta=ChoiceDelta(content=content_chunk))]
+                                    )
+                                    yield f"data: {chunk_obj.model_dump_json()}\n\n"
+                            # Add logic here to detect the end of the stream if Notion has a specific marker
+                            # For now, we assume markdown-chat stops when the main content is done.
+                            # If we see a recordMap, it's definitely past the text stream.
+                            elif "recordMap" in data:
+                                print("Detected recordMap, stopping stream.")
+                                # Process any remaining buffer
+                                if buffer.strip():
+                                    try:
+                                        last_data = json.loads(buffer.strip())
+                                        if last_data.get("type") == "markdown-chat" and isinstance(last_data.get("value"), str):
+                                            if last_data["value"]:
+                                                last_chunk = ChatCompletionChunk(
+                                                    id=chunk_id,
+                                                    created=created_time,
+                                                    choices=[Choice(delta=ChoiceDelta(content=last_data["value"]))]
+                                                )
+                                                yield f"data: {last_chunk.model_dump_json()}\n\n"
+                                    except:
+                                        pass
+                                # Exit the loop
+                                break
+
+                        except json.JSONDecodeError as e:
+                            print(f"Warning: Could not decode JSON line: {line[:100]}... Error: {str(e)}")
+                        except Exception as e:
+                            print(f"Error processing line: {str(e)}")
+                            # Continue processing other lines
+                    
+                    if is_error_response:
+                        break
+                
+                # 如果检测到错误，进行重试
+                if is_error_response:
+                    if attempt < max_retries - 1:
+                        print(f"等待 {retry_delay} 秒后重试...")
+                        await asyncio.sleep(retry_delay)
+                        continue  # 重试
+                    else:
+                        # 所有重试都失败了，通过流式响应返回错误信息
+                        print("所有重试都失败，返回500错误给客户端")
+                        error_chunk = ChatCompletionChunk(
+                            id=chunk_id,
+                            created=created_time,
+                            choices=[Choice(delta=ChoiceDelta(content="Error: Notion API returned error code 500 after all retries"), finish_reason="stop")]
+                        )
+                        yield f"data: {error_chunk.model_dump_json()}\n\n"
+                        yield "data: [DONE]\n\n"
+                        return
+                
+                # 如果没有错误，发送最终的停止信号
+                # Send the final chunk indicating stop
+                final_chunk = ChatCompletionChunk(
+                    id=chunk_id,
+                    created=created_time,
+                    choices=[Choice(delta=ChoiceDelta(), finish_reason="stop")]
+                )
+                yield f"data: {final_chunk.model_dump_json()}\n\n"
+                yield "data: [DONE]\n\n"
+                
+                # 成功完成，退出重试循环
+                break
+
+        except HTTPException:
+            # 在流式响应中不能抛出HTTPException，通过流式响应返回错误
+            if attempt < max_retries - 1:
+                print(f"HTTP异常，等待 {retry_delay} 秒后重试...")
+                await asyncio.sleep(retry_delay)
+                continue
+            else:
+                print("HTTP异常且无更多重试，返回错误信息")
+                error_chunk = ChatCompletionChunk(
+                    id=chunk_id,
+                    created=created_time,
+                    choices=[Choice(delta=ChoiceDelta(content="Error: HTTP exception occurred after all retries"), finish_reason="stop")]
+                )
+                yield f"data: {error_chunk.model_dump_json()}\n\n"
+                yield "data: [DONE]\n\n"
+                return
+        except Exception as e:
+            print(f"Unexpected error during streaming (attempt {attempt + 1}/{max_retries}): {e}")
+            if attempt < max_retries - 1:
+                print(f"等待 {retry_delay} 秒后重试...")
+                await asyncio.sleep(retry_delay)
+                continue
+            else:
+                print("意外错误且无更多重试，返回错误信息")
+                error_chunk = ChatCompletionChunk(
+                    id=chunk_id,
+                    created=created_time,
+                    choices=[Choice(delta=ChoiceDelta(content=f"Error: Internal server error during streaming: {e}"), finish_reason="stop")]
+                )
+                yield f"data: {error_chunk.model_dump_json()}\n\n"
+                yield "data: [DONE]\n\n"
+                return
+
+
+# --- API Endpoints ---
+
+@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.
+    """
+    if not NOTION_COOKIE:
+        raise HTTPException(status_code=500, detail="Server configuration error: Notion cookie not set.")
+
+    notion_request_body = build_notion_request(request_data)
+
+    if request_data.stream:
+        return StreamingResponse(
+            stream_notion_response(notion_request_body),
+            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())
+
+        try:
+            async for line in stream_notion_response(notion_request_body):
+                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")
+
+if __name__ == "__main__":
+    import uvicorn
+    print("Starting server. Access at http://localhost:7860")
+    print("Ensure NOTION_COOKIE is set in your .env file or environment.")
+    print("Cookie管理系统已启用，将自动获取和更新Notion浏览器cookie")
+    
+    # 运行服务器
+    uvicorn.run(app, host="0.0.0.0", port=7860)

models.py

@@ -7,12 +7,8 @@ from typing import List, Optional, Dict, Any, Literal, Union
 
 # 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
+    content: str
 
 class ChatCompletionRequest(BaseModel):
     messages: List[ChatMessage]
@@ -30,23 +26,9 @@ 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
+    type: Literal["config", "user", "markdown-chat"]
+    value: Union[List[List[str]], str, NotionTranscriptConfigValue]
 
 class NotionDebugOverrides(BaseModel):
     cachedInferences: Dict = Field(default_factory=dict)
@@ -63,12 +45,6 @@ class NotionRequestBody(BaseModel):
     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):

requirements.txt

@@ -1,5 +1,5 @@
-fastapi
-uvicorn[standard]
-httpx
-pydantic
-python-dotenv
+fastapi
+uvicorn[standard]
+curl-cffi
+pydantic
+python-dotenv