Merge pull request #17 from BrainDriveAI/feature/conversation-page-id

Add `page_id` Support to Conversations and Page Context Awareness

Author: DJJones66

backend/app/api/v1/endpoints/ai_providers.py

@@ -497,6 +497,7 @@ async def chat_completion(request: ChatCompletionRequest, db: AsyncSession = Dep
                     user_id=user_id,
                     title=f"Conversation with {request.model}",
                     page_context=request.page_context,  # This is already defined in the schema with a default of None
+                    page_id=request.page_id,  # NEW FIELD - ID of the page this conversation belongs to
                     model=request.model,
                     server=provider_instance.server_name,
                     conversation_type=request.conversation_type or "chat"  # New field with default

backend/app/api/v1/endpoints/conversations.py

@@ -30,6 +30,7 @@ async def get_user_conversations(
     limit: int = Query(20, ge=1, le=100),
     tag_id: Optional[str] = Query(None, description="Filter by tag ID"),
     conversation_type: Optional[str] = Query(None, description="Filter by conversation type"),
+    page_id: Optional[str] = Query(None, description="Filter by page ID"),
     db: AsyncSession = Depends(get_db),
     current_user = Depends(get_current_user)
 ):
@@ -48,6 +49,10 @@ async def get_user_conversations(
 
     query = select(Conversation).where(Conversation.user_id == formatted_user_id)
 
+    # Filter by page_id if provided
+    if page_id:
+        query = query.where(Conversation.page_id == page_id)
+    
     # Filter by tag if provided
     if tag_id:
         query = query.join(
@@ -97,6 +102,7 @@ async def create_conversation(
         user_id=conversation_user_id,  # Use formatted user ID
         title=conversation.title,
         page_context=conversation.page_context,
+        page_id=conversation.page_id,  # NEW FIELD
         model=conversation.model,
         server=conversation.server,
         conversation_type=conversation.conversation_type or "chat"  # New field with default
@@ -161,6 +167,8 @@ async def update_conversation(
         conversation.title = conversation_update.title
     if conversation_update.page_context is not None:
         conversation.page_context = conversation_update.page_context
+    if conversation_update.page_id is not None:
+        conversation.page_id = conversation_update.page_id
     if conversation_update.model is not None:
         conversation.model = conversation_update.model
     if conversation_update.server is not None:

backend/app/models/conversation.py

@@ -1,6 +1,6 @@
 import uuid
 from datetime import datetime
-from sqlalchemy import Column, String, Text, ForeignKey, DateTime, select
+from sqlalchemy import Column, String, Text, ForeignKey, DateTime, select, func
 from sqlalchemy.dialects.postgresql import JSON
 # Remove PostgreSQL UUID import as we're standardizing on String
 from sqlalchemy.orm import relationship
@@ -14,6 +14,7 @@ class Conversation(Base, TimestampMixin):
     user_id = Column(String, ForeignKey("users.id"), nullable=False)
     title = Column(String)
     page_context = Column(String)  # e.g., 'home', 'editor', 'chatbot_lab'
+    page_id = Column(String(32), nullable=True)  # NEW - specific page ID for page-specific conversations
     model = Column(String)  # Store which model was used
     server = Column(String)  # Store which server was used
     conversation_type = Column(String(100), nullable=True, default="chat")  # New field for categorization
@@ -104,6 +105,36 @@ async def get_by_user_id(cls, db, user_id, skip=0, limit=100):
         result = await db.execute(query)
         return result.scalars().all()
 
+    @classmethod
+    async def get_by_user_id_and_page(cls, db, user_id, page_id=None, conversation_type=None, skip=0, limit=100):
+        """Get conversations for user, optionally filtered by page_id and conversation_type."""
+        formatted_user_id = str(user_id).replace('-', '')
+        query = select(cls).where(cls.user_id == formatted_user_id)
+        
+        # Filter by page_id if provided
+        if page_id:
+            query = query.where(cls.page_id == page_id)
+        
+        # Filter by conversation_type if provided
+        if conversation_type:
+            query = query.where(cls.conversation_type == conversation_type)
+        
+        query = query.order_by(cls.updated_at.desc()).offset(skip).limit(limit)
+        result = await db.execute(query)
+        return result.scalars().all()
+
+    @classmethod
+    async def count_by_user_and_page(cls, db, user_id, page_id=None):
+        """Count conversations for user, optionally filtered by page_id."""
+        formatted_user_id = str(user_id).replace('-', '')
+        query = select(func.count(cls.id)).where(cls.user_id == formatted_user_id)
+        
+        if page_id:
+            query = query.where(cls.page_id == page_id)
+        
+        result = await db.execute(query)
+        return result.scalar()
+
     async def get_messages(self, db, skip=0, limit=100):
         """Get all messages for this conversation with pagination."""
         from app.models.message import Message

backend/app/schemas/ai_providers.py

@@ -22,6 +22,9 @@ class TextGenerationRequest(BaseModel):
     user_id: Optional[str] = Field(None, description="User ID for access control")
     params: Dict[str, Any] = Field(default_factory=dict, description="Additional parameters")
     stream: bool = Field(False, description="Whether to stream the response")
+    page_id: Optional[str] = Field(None, description="ID of the page this generation belongs to")
+    page_context: Optional[str] = Field(None, description="Context of the page where this generation is happening")
+    conversation_type: Optional[str] = Field("chat", description="Type/category of the conversation")
 
 
 class ChatMessage(BaseModel):
@@ -41,6 +44,7 @@ class ChatCompletionRequest(BaseModel):
     params: Dict[str, Any] = Field(default_factory=dict, description="Additional parameters")
     stream: bool = Field(False, description="Whether to stream the response")
     conversation_id: Optional[str] = Field(None, description="ID of an existing conversation to continue")
+    page_id: Optional[str] = Field(None, description="ID of the page this conversation belongs to")
     page_context: Optional[str] = Field(None, description="Context where the conversation is taking place (e.g., 'home', 'editor', 'chatbot_lab')")
     conversation_type: Optional[str] = Field("chat", description="Type/category of the conversation (e.g., 'chat', 'email_reply', 'therapy')")
 

backend/app/schemas/conversation_schemas.py

@@ -33,6 +33,7 @@ class Message(MessageInDB):
 class ConversationBase(BaseModel):
     title: Optional[str] = Field(None, description="Title of the conversation")
     page_context: Optional[str] = Field(None, description="Context where the conversation was created")
+    page_id: Optional[str] = Field(None, description="ID of the page this conversation belongs to")
     model: Optional[str] = Field(None, description="LLM model used for the conversation")
     server: Optional[str] = Field(None, description="Server used for the conversation")
     conversation_type: Optional[str] = Field("chat", description="Type/category of the conversation (e.g., 'chat', 'email_reply', 'therapy')")

backend/migrations/versions/add_page_id_to_conversations.py

@@ -0,0 +1,41 @@
+"""add page_id to conversations
+
+Revision ID: add_page_id_to_conversations
+Revises: add_conversation_type_simple
+Create Date: 2025-06-25 13:00:00.000000
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision: str = 'add_page_id_to_conversations'
+down_revision: Union[str, None] = 'add_conversation_type_simple'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # Add page_id column to conversations table
+    # Using batch_alter_table for SQLite compatibility
+    with op.batch_alter_table('conversations', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('page_id', sa.String(length=32), nullable=True))
+    
+    # Add indexes for efficient querying (SQLite compatible)
+    op.create_index('idx_conversations_page_id', 'conversations', ['page_id'], unique=False)
+    op.create_index('idx_conversations_user_page', 'conversations', ['user_id', 'page_id'], unique=False)
+    
+    # Note: Existing conversations will have page_id = NULL (treated as global conversations)
+    # New page-specific conversations will have specific page_id values
+
+
+def downgrade() -> None:
+    # Remove indexes first
+    op.drop_index('idx_conversations_user_page', table_name='conversations')
+    op.drop_index('idx_conversations_page_id', table_name='conversations')
+    
+    # Remove page_id column using batch_alter_table for SQLite compatibility
+    with op.batch_alter_table('conversations', schema=None) as batch_op:
+        batch_op.drop_column('page_id')

backend/migrations/versions/c7eed881f009_merge_heads.py

@@ -0,0 +1,26 @@
+"""merge heads
+
+Revision ID: c7eed881f009
+Revises: restore_settings_tables, add_page_id_to_conversations
+Create Date: 2025-06-25 13:34:43.475716
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'c7eed881f009'
+down_revision: Union[str, None] = ('restore_settings_tables', 'add_page_id_to_conversations')
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    pass
+
+
+def downgrade() -> None:
+    pass

frontend/src/App.tsx

@@ -10,6 +10,7 @@ import { SettingsService } from './services/SettingsService';
 import { UserSettingsInitService } from './services/UserSettingsInitService';
 import { userNavigationInitService } from './services/UserNavigationInitService';
 import { eventService } from './services/EventService';
+import { pageContextService } from './services/PageContextService';
 import { useAppTheme } from './hooks/useAppTheme';
 import { config } from './config';
 import { PluginManager } from './components/PluginManager';
@@ -38,6 +39,7 @@ serviceRegistry.registerService(settingsService);
 serviceRegistry.registerService(userSettingsInitService);
 serviceRegistry.registerService(userNavigationInitService);
 serviceRegistry.registerService(eventService);
+serviceRegistry.registerService(pageContextService);
 
 function AppContent() {
   const theme = useAppTheme();

frontend/src/components/DynamicPageRenderer.tsx

@@ -19,6 +19,7 @@ import { defaultPageService } from '../services/defaultPageService';
 import { PluginModuleRenderer } from './PluginModuleRenderer';
 import { PluginProvider } from '../contexts/PluginContext';
 import { getAvailablePlugins } from '../plugins';
+import { pageContextService } from '../services/PageContextService';
 
 interface DynamicPageRendererProps {
   pageId?: string;  // Optional: directly specify page ID
@@ -124,21 +125,32 @@ export const DynamicPageRenderer: React.FC<DynamicPageRendererProps> = ({ pageId
   // Memoize the current page ID to prevent unnecessary recalculations
   const currentId = useMemo(() => getPageId(), [pageId, route, location.pathname]);
 
-  // Update global variables when page or studio status changes
+  // Update global variables and page context when page or studio status changes
   useEffect(() => {
     if (page) {
       window.currentPageTitle = page.name;
       window.isStudioPage = isStudioPage;
 
+      // Update the page context service
+      const pageContextData = {
+        pageId: page.id || currentId,
+        pageName: page.name || 'Unknown Page',
+        pageRoute: page.route || location.pathname,
+        isStudioPage
+      };
+      
+      pageContextService.setPageContext(pageContextData);
+
       console.log('DynamicPageRenderer - Current path:', location.pathname);
       console.log('DynamicPageRenderer - Is studio page:', isStudioPage);
       console.log('DynamicPageRenderer - Page name:', page.name);
+      console.log('DynamicPageRenderer - Page context updated:', pageContextData);
       console.log('DynamicPageRenderer - Global variables:', {
         currentPageTitle: window.currentPageTitle,
         isStudioPage: window.isStudioPage
       });
     }
-  }, [page, isStudioPage, location.pathname]);
+  }, [page, currentId, isStudioPage, location.pathname]);
 
   // Function to handle module state changes
   const handleModuleStateChange = useCallback((moduleId: string, state: any) => {

frontend/src/services/PageContextService.ts

@@ -0,0 +1,80 @@
+import { AbstractBaseService } from './base/BaseService';
+
+export interface PageContextData {
+  pageId: string;
+  pageName: string;
+  pageRoute: string;
+  isStudioPage: boolean;
+}
+
+export interface PageContextServiceInterface {
+  getCurrentPageContext(): PageContextData | null;
+  onPageContextChange(callback: (context: PageContextData) => void): () => void;
+}
+
+class PageContextServiceImpl extends AbstractBaseService implements PageContextServiceInterface {
+  private currentContext: PageContextData | null = null;
+  private listeners: ((context: PageContextData) => void)[] = [];
+  private static instance: PageContextServiceImpl;
+
+  private constructor() {
+    super(
+      'pageContext',
+      { major: 1, minor: 0, patch: 0 },
+      [
+        {
+          name: 'page-context-management',
+          description: 'Page context tracking and management capabilities',
+          version: '1.0.0'
+        },
+        {
+          name: 'page-context-events',
+          description: 'Page context change event subscription system',
+          version: '1.0.0'
+        }
+      ]
+    );
+  }
+
+  public static getInstance(): PageContextServiceImpl {
+    if (!PageContextServiceImpl.instance) {
+      PageContextServiceImpl.instance = new PageContextServiceImpl();
+    }
+    return PageContextServiceImpl.instance;
+  }
+
+  async initialize(): Promise<void> {
+    // Initialize the service - no special initialization needed for now
+    console.log('[PageContextService] Initialized');
+  }
+
+  async destroy(): Promise<void> {
+    // Clean up listeners
+    this.listeners = [];
+    this.currentContext = null;
+    console.log('[PageContextService] Destroyed');
+  }
+
+  getCurrentPageContext(): PageContextData | null {
+    return this.currentContext;
+  }
+
+  setPageContext(context: PageContextData): void {
+    this.currentContext = context;
+    this.listeners.forEach(listener => listener(context));
+  }
+
+  onPageContextChange(callback: (context: PageContextData) => void): () => void {
+    this.listeners.push(callback);
+    
+    // Return unsubscribe function
+    return () => {
+      const index = this.listeners.indexOf(callback);
+      if (index > -1) {
+        this.listeners.splice(index, 1);
+      }
+    };
+  }
+}
+
+export const pageContextService = PageContextServiceImpl.getInstance();