first commit

.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,28 @@
+# 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
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,96 @@
+---
+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
+
+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 `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).
+
+## 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` and `NOTION_SPACE_ID`:
+    ```dotenv
+    NOTION_COOKIE="your_cookie_value_here"
+    NOTION_SPACE_ID="your_space_id_here"
+    ```
+4.  Run the application using Uvicorn:
+    ```bash
+    uvicorn main:app --reload --port 7860
+    ```
+    The server will be available at `http://localhost:7860`.
+
+## 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` and `NOTION_SPACE_ID`.
+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`.
+
+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"` and `"your_space_id"` with your actual Notion credentials.
+    ```bash
+    docker run -p 7860:7860 \
+      -e NOTION_COOKIE="your_cookie_value" \
+      -e NOTION_SPACE_ID="your_space_id" \
+      notion-api-bridge
+    ```
+    The server will be available at `http://localhost:7860` (or whichever host port you mapped to the container's 7860).
+
+## 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 your Notion Space ID.
+    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. For example, if your Space URL is `https://your-username-your-space-name.hf.space`, you can send requests like:
+    ```bash
+    curl -X POST https://your-username-your-space-name.hf.space/v1/chat/completions \
+      -H "Content-Type: application/json" \
+      -d '{
+            "model": "gpt-3.5-turbo", # Model name is often ignored by bridge, but required by spec
+            "messages": [{"role": "user", "content": "Add a new page titled '\''Meeting Notes'\'' with content '\''Discuss project roadmap'\''"}]
+          }'

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,253 @@
+import os
+import uuid
+import json
+import time
+import httpx
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import StreamingResponse
+from dotenv import load_dotenv
+from .models import (
+    ChatMessage, ChatCompletionRequest, NotionTranscriptConfigValue,
+    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
+
+# --- FastAPI App ---
+app = FastAPI()
+
+# --- 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 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,zh-CN;q=0.8,zh;q=0.7,zh-TW;q=0.6,ja;q=0.5',
+        'content-type': 'application/json',
+        'notion-audit-log-platform': 'web',
+        'notion-client-version': '23.13.0.3604', # 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',
+        '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
+    }
+
+    chunk_id = f"chatcmpl-{uuid.uuid4()}"
+    created_time = int(time.time())
+
+    try:
+        async with httpx.AsyncClient(timeout=None) as client: # No timeout for streaming
+            async with client.stream("POST", NOTION_API_URL, json=notion_request_body.dict(), 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():
+    """
+    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):
+    """
+    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)

models.py

@@ -0,0 +1,76 @@
+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):
+    role: Literal["system", "user", "assistant"]
+    content: str
+
+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 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]

requirements.txt

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