added extra field to make message look more like website trace

main.py

@@ -2,16 +2,19 @@ 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,
-    NotionTranscriptItem, NotionDebugOverrides, NotionRequestBody,
-    ChoiceDelta, Choice, ChatCompletionChunk, Model, ModelList
+    NotionTranscriptContextValue, NotionTranscriptItem, NotionDebugOverrides,
+    NotionRequestBody, ChoiceDelta, Choice, ChatCompletionChunk, Model, ModelList
 )
 
 # Load environment variables from .env file
@@ -53,43 +56,131 @@ app = FastAPI()
 # --- Helper Functions ---
 
 def build_notion_request(request_data: ChatCompletionRequest) -> NotionRequestBody:
-    """Transforms OpenAI-style messages to Notion transcript format."""
+    """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")
+    user_messages = [msg for msg in request_data.messages if msg.role == "user"]
+    num_user_messages = len(user_messages)
+    user_message_timestamps = {} # Store timestamps keyed by message id
+
+    if num_user_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 user message
+        last_user_msg_id = user_messages[-1].id
+        user_message_timestamps[last_user_msg_id] = now_pacific
+
+        # Calculate timestamps for previous user messages (10 mins earlier each)
+        current_timestamp = now_pacific
+        for i in range(num_user_messages - 2, -1, -1): # Iterate backwards from second-to-last
+            current_timestamp -= timedelta(minutes=random.randint(3, 20)) # Use random interval (3-20 mins)
+            user_message_timestamps[user_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:
-        # 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:  # Handles 'user', 'system', etc.
+            # Assistant messages get a traceId, but not userId or createdAt
+            transcript.append(NotionTranscriptItem(
+                type="markdown-chat",
+                value=message.content,
+                traceId=str(uuid.uuid4()) # Generate unique traceId for assistant message
+            ))
+        elif message.role == "user":
+            created_at_dt = user_message_timestamps.get(message.id)
+            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
             if isinstance(content, str):
-                # Handle string content: Append one item, using default [[""]] for empty strings
                 notion_value = [[content]] if content else [[""]]
-                transcript.append(NotionTranscriptItem(type="user", value=notion_value))
+                transcript.append(NotionTranscriptItem(
+                    type="user",
+                    value=notion_value,
+                    userId=user_id,
+                    createdAt=created_at_iso
+                ))
             elif isinstance(content, list):
-                # Handle list content: Append a SEPARATE item for each valid text part
                 found_text_part = False
                 for part in content:
-                    # Check if part is a dict with type="text" and non-empty text
-                    if isinstance(part, dict) and part.get("type") == "text":
+                     if isinstance(part, dict) and part.get("type") == "text":
                         text_content = part.get("text")
                         if isinstance(text_content, str) and text_content:
-                            # Create and append a SEPARATE item for this text part
-                            transcript.append(NotionTranscriptItem(type="user", value=[[text_content]]))
+                            # Append separate item for each text part, with same userId/timestamp
+                            transcript.append(NotionTranscriptItem(
+                                type="user",
+                                value=[[text_content]],
+                                userId=user_id,
+                                createdAt=created_at_iso
+                            ))
                             found_text_part = True
-                # If the list was empty or had no valid text parts, append a default empty item to maintain behavior
                 if not found_text_part:
-                    print(f'Error: no valid input found: {message}')
-                    transcript.append(NotionTranscriptItem(type="user", value=[[""]]))
+                    # Append default empty item if no valid text parts found
+                    transcript.append(NotionTranscriptItem(
+                        type="user",
+                        value=[[""]],
+                        userId=user_id,
+                        createdAt=created_at_iso # Still add userId/timestamp
+                    ))
+                    print(f'Warning: No valid text parts found in user message list content: {message}')
             else:
-                # Handle unexpected content types (e.g., None, int) by appending a default empty item
-                transcript.append(NotionTranscriptItem(type="user", value=[[""]]))
-                print(f'Error: no valid input found: {message}')
+                 # Handle unexpected content types with default empty item
+                transcript.append(NotionTranscriptItem(
+                    type="user",
+                    value=[[""]],
+                    userId=user_id,
+                    createdAt=created_at_iso # Still add userId/timestamp
+                ))
+                print(f'Warning: Unexpected content type in user message: {message}')
+        # System messages are currently ignored in the Notion transcript based on original logic
+        # else: # Handle 'system' role if needed in the future
 
     # Use globally configured spaceId, set createThread=True
     return NotionRequestBody(
@@ -112,10 +203,10 @@ 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',
+        'accept-language': 'en-US,en;q=0.9',
         'content-type': 'application/json',
         'notion-audit-log-platform': 'web',
-        'notion-client-version': '23.13.0.3604', # Consider making this configurable
+        '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.

models.py

@@ -7,8 +7,12 @@ 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
 
 class ChatCompletionRequest(BaseModel):
     messages: List[ChatMessage]
@@ -26,9 +30,23 @@ 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):
-    type: Literal["config", "user", "markdown-chat"]
-    value: Union[List[List[str]], str, NotionTranscriptConfigValue]
+    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)