# Copyright (c) 2025 Patrick Motsch # All rights reserved. """ Teamsbot routes for the backend API. Implements Teams Bot session management, live streaming, and configuration endpoints. """ import logging import json import re import asyncio from typing import Optional from urllib.parse import urlparse, parse_qs, unquote from fastapi import APIRouter, HTTPException, Depends, WebSocket, WebSocketDisconnect, Query, Request from fastapi.responses import StreamingResponse # Import auth modules from modules.auth import limiter, getRequestContext, RequestContext # Import interfaces from . import interfaceFeatureTeamsbot as interfaceDb from modules.interfaces.interfaceDbApp import getRootInterface from modules.interfaces.interfaceFeatures import getFeatureInterface # Import models from .datamodelTeamsbot import ( TeamsbotSession, TeamsbotSessionStatus, TeamsbotStartSessionRequest, TeamsbotSessionResponse, TeamsbotConfigUpdateRequest, TeamsbotConfig, ) # Import service from .service import TeamsbotService logger = logging.getLogger(__name__) # Create router router = APIRouter( prefix="/api/teamsbot", tags=["Teamsbot"], responses={404: {"description": "Not found"}} ) # ========================================================================= # Helpers # ========================================================================= def _extractTeamsMeetingUrl(rawInput: str) -> str: """ Extract a clean Teams meeting URL from various input formats: - Full invitation text (extracts the URL from surrounding text) - SafeLinks wrapped URLs (decodes the inner url= parameter) - Already clean Teams URLs (passed through) Raises HTTPException if no valid Teams URL can be found. """ rawInput = rawInput.strip() # Step 1: Extract any URL from the text (user may have pasted full invitation) urlPattern = r'https?://[^\s<>"\')\]]+' urls = re.findall(urlPattern, rawInput) if not urls: raise HTTPException(status_code=400, detail="Kein gültiger Meeting-Link gefunden. Bitte einen Teams-Link eingeben.") # Step 2: Find the Teams URL (prefer direct teams.microsoft.com, then SafeLinks) teamsUrl = None safeLinksUrl = None for url in urls: url = url.rstrip(".,;:)") # Strip trailing punctuation parsed = urlparse(url) if "teams.microsoft.com" in parsed.netloc: teamsUrl = url break elif "safelinks.protection.outlook.com" in parsed.netloc: safeLinksUrl = url # Step 3: Unwrap SafeLinks if no direct Teams URL found if not teamsUrl and safeLinksUrl: parsed = urlparse(safeLinksUrl) params = parse_qs(parsed.query) innerUrl = params.get("url", [None])[0] if innerUrl: teamsUrl = unquote(innerUrl) # Step 4: If raw input itself is a Teams URL (simplest case) if not teamsUrl and "teams.microsoft.com" in rawInput: teamsUrl = rawInput if not teamsUrl or "teams.microsoft.com" not in teamsUrl: raise HTTPException( status_code=400, detail="Kein gültiger Teams-Meeting-Link gefunden. Der Link muss 'teams.microsoft.com' enthalten." ) logger.info(f"Extracted meeting URL: {teamsUrl[:80]}... (from input length {len(rawInput)})") return teamsUrl def _getInterface(context: RequestContext, instanceId: Optional[str] = None): """Get teamsbot interface with instance context.""" mandateId = str(context.mandateId) if context.mandateId else None return interfaceDb.getInterface( context.user, mandateId=mandateId, featureInstanceId=instanceId ) def _validateInstanceAccess(instanceId: str, context: RequestContext) -> str: """Validate user access to the feature instance. Returns mandateId.""" rootInterface = getRootInterface() featureInterface = getFeatureInterface(rootInterface.db) instance = featureInterface.getFeatureInstance(instanceId) if not instance: raise HTTPException(status_code=404, detail=f"Feature instance '{instanceId}' not found") mandateId = instance.get("mandateId") if isinstance(instance, dict) else getattr(instance, "mandateId", None) if not mandateId: raise HTTPException(status_code=500, detail="Feature instance has no mandateId") return str(mandateId) def _getInstanceConfig(instanceId: str) -> TeamsbotConfig: """Load TeamsbotConfig from FeatureInstance.config JSONB field.""" rootInterface = getRootInterface() featureInterface = getFeatureInterface(rootInterface.db) instance = featureInterface.getFeatureInstance(instanceId) if not instance: return TeamsbotConfig() configDict = instance.get("config") if isinstance(instance, dict) else getattr(instance, "config", None) if configDict and isinstance(configDict, dict): try: return TeamsbotConfig(**configDict) except Exception: pass return TeamsbotConfig() # ========================================================================= # Session Endpoints # ========================================================================= @router.post("/{instanceId}/sessions") @limiter.limit("10/minute") async def startSession( request: Request, instanceId: str, body: TeamsbotStartSessionRequest, context: RequestContext = Depends(getRequestContext), ): """Start a new Teams Bot session -- bot joins the specified meeting.""" mandateId = _validateInstanceAccess(instanceId, context) interface = _getInterface(context, instanceId) config = _getInstanceConfig(instanceId) # Extract and validate meeting URL from user input (handles SafeLinks, invitation text, etc.) cleanMeetingUrl = _extractTeamsMeetingUrl(body.meetingLink) # Create session sessionData = TeamsbotSession( instanceId=instanceId, mandateId=mandateId, meetingLink=cleanMeetingUrl, botName=body.botName or config.botName, backgroundImageUrl=body.backgroundImageUrl or config.backgroundImageUrl, status=TeamsbotSessionStatus.PENDING, startedByUserId=str(context.user.id), ).model_dump() createdSession = interface.createSession(sessionData) sessionId = createdSession.get("id") # Use APP_API_URL from global config for the gateway base URL # request.base_url can be http:// behind a reverse proxy even when client uses https:// from modules.shared.configuration import APP_CONFIG appApiUrl = APP_CONFIG.get("APP_API_URL", "") gatewayBaseUrl = appApiUrl.rstrip("/") if appApiUrl else str(request.base_url).rstrip("/") # Start the bot in background (join meeting via bridge) service = TeamsbotService(context.user, mandateId, instanceId, config) asyncio.create_task( service.joinMeeting(sessionId, cleanMeetingUrl, body.connectionId, gatewayBaseUrl) ) logger.info(f"Teamsbot session {sessionId} created for instance {instanceId}") return {"session": createdSession} @router.get("/{instanceId}/sessions") @limiter.limit("30/minute") async def listSessions( request: Request, instanceId: str, includeEnded: bool = Query(True, description="Include ended sessions"), context: RequestContext = Depends(getRequestContext), ): """List all sessions for a feature instance.""" _validateInstanceAccess(instanceId, context) interface = _getInterface(context, instanceId) sessions = interface.getSessions(instanceId, includeEnded=includeEnded) return {"sessions": sessions} @router.get("/{instanceId}/sessions/{sessionId}") @limiter.limit("30/minute") async def getSession( request: Request, instanceId: str, sessionId: str, includeTranscripts: bool = Query(True), includeResponses: bool = Query(True), context: RequestContext = Depends(getRequestContext), ): """Get session details with optional transcripts and bot responses.""" _validateInstanceAccess(instanceId, context) interface = _getInterface(context, instanceId) session = interface.getSession(sessionId) if not session: raise HTTPException(status_code=404, detail=f"Session '{sessionId}' not found") result = {"session": session} if includeTranscripts: result["transcripts"] = interface.getTranscripts(sessionId) if includeResponses: result["botResponses"] = interface.getBotResponses(sessionId) result["stats"] = interface.getSessionStats(sessionId) return result @router.get("/{instanceId}/sessions/{sessionId}/stream") @limiter.limit("10/minute") async def streamSession( request: Request, instanceId: str, sessionId: str, context: RequestContext = Depends(getRequestContext), ): """ SSE live stream for a session. Streams transcript segments and bot responses in real-time. Events: transcript, botResponse, statusChange, error """ _validateInstanceAccess(instanceId, context) interface = _getInterface(context, instanceId) session = interface.getSession(sessionId) if not session: raise HTTPException(status_code=404, detail=f"Session '{sessionId}' not found") async def _eventGenerator(): """Generate SSE events from the session event queue.""" from .service import _sessionEvents # Send initial session state yield f"data: {json.dumps({'type': 'sessionState', 'data': session})}\n\n" # Stream events eventQueue = _sessionEvents.get(sessionId) if not eventQueue: _sessionEvents[sessionId] = asyncio.Queue() eventQueue = _sessionEvents[sessionId] try: while True: try: event = await asyncio.wait_for(eventQueue.get(), timeout=30.0) yield f"data: {json.dumps(event)}\n\n" # Stop streaming if session ended if event.get("type") == "statusChange" and event.get("data", {}).get("status") in ["ended", "error"]: break except asyncio.TimeoutError: # Send keepalive ping yield f"data: {json.dumps({'type': 'ping'})}\n\n" except asyncio.CancelledError: pass return StreamingResponse( _eventGenerator(), media_type="text/event-stream", headers={ "Cache-Control": "no-cache", "Connection": "keep-alive", "X-Accel-Buffering": "no", } ) @router.post("/{instanceId}/sessions/{sessionId}/stop") @limiter.limit("10/minute") async def stopSession( request: Request, instanceId: str, sessionId: str, context: RequestContext = Depends(getRequestContext), ): """Stop an active session -- bot leaves the meeting.""" mandateId = _validateInstanceAccess(instanceId, context) interface = _getInterface(context, instanceId) config = _getInstanceConfig(instanceId) session = interface.getSession(sessionId) if not session: raise HTTPException(status_code=404, detail=f"Session '{sessionId}' not found") currentStatus = session.get("status") if currentStatus in [TeamsbotSessionStatus.ENDED.value, TeamsbotSessionStatus.ERROR.value]: raise HTTPException(status_code=400, detail=f"Session already in terminal state: {currentStatus}") # Stop the bot service = TeamsbotService(context.user, mandateId, instanceId, config) await service.leaveMeeting(sessionId) logger.info(f"Teamsbot session {sessionId} stop requested") return {"status": "stopping", "sessionId": sessionId} @router.delete("/{instanceId}/sessions/{sessionId}") @limiter.limit("10/minute") async def deleteSession( request: Request, instanceId: str, sessionId: str, context: RequestContext = Depends(getRequestContext), ): """Delete a session and all related data.""" _validateInstanceAccess(instanceId, context) interface = _getInterface(context, instanceId) session = interface.getSession(sessionId) if not session: raise HTTPException(status_code=404, detail=f"Session '{sessionId}' not found") # Don't delete active sessions currentStatus = session.get("status") if currentStatus in [TeamsbotSessionStatus.ACTIVE.value, TeamsbotSessionStatus.JOINING.value]: raise HTTPException(status_code=400, detail="Cannot delete an active session. Stop it first.") interface.deleteSession(sessionId) logger.info(f"Teamsbot session {sessionId} deleted") return {"deleted": True, "sessionId": sessionId} # ========================================================================= # Configuration Endpoints # ========================================================================= @router.get("/{instanceId}/config") @limiter.limit("30/minute") async def getConfig( request: Request, instanceId: str, context: RequestContext = Depends(getRequestContext), ): """Get the teamsbot configuration for a feature instance.""" _validateInstanceAccess(instanceId, context) config = _getInstanceConfig(instanceId) return {"config": config.model_dump()} @router.put("/{instanceId}/config") @limiter.limit("10/minute") async def updateConfig( request: Request, instanceId: str, configUpdate: TeamsbotConfigUpdateRequest, context: RequestContext = Depends(getRequestContext), ): """Update the teamsbot configuration.""" mandateId = _validateInstanceAccess(instanceId, context) # Load current config and merge updates currentConfig = _getInstanceConfig(instanceId) updateDict = configUpdate.model_dump(exclude_none=True) mergedConfig = currentConfig.model_copy(update=updateDict) # Save to FeatureInstance.config rootInterface = getRootInterface() featureInterface = getFeatureInterface(rootInterface.db) featureInterface.updateFeatureInstance(instanceId, {"config": mergedConfig.model_dump()}) logger.info(f"Teamsbot config updated for instance {instanceId}: {list(updateDict.keys())}") return {"config": mergedConfig.model_dump()} # ========================================================================= # Voice Test Endpoint # ========================================================================= @router.post("/{instanceId}/voice/test") @limiter.limit("10/minute") async def testVoice( request: Request, instanceId: str, context: RequestContext = Depends(getRequestContext), ): """Test TTS voice with AI-generated sample text in the correct language.""" from modules.interfaces.interfaceVoiceObjects import getVoiceInterface from modules.services.serviceAi.mainServiceAi import AiService from modules.datamodels.datamodelAi import AiCallRequest, AiCallOptions, OperationTypeEnum, PriorityEnum mandateId = _validateInstanceAccess(instanceId, context) body = await request.json() language = body.get("language", "de-DE") voiceId = body.get("voiceId") botName = body.get("botName", "AI Assistant") try: # Generate test text dynamically via AI in the correct language serviceContext = type('Ctx', (), { 'user': context.user, 'mandateId': mandateId, 'featureInstanceId': instanceId, 'featureCode': 'teamsbot' })() aiService = AiService(serviceCenter=serviceContext) await aiService.ensureAiObjectsInitialized() aiRequest = AiCallRequest( prompt=f"Generate a short, friendly introduction sentence (max 2 sentences) for a meeting bot named '{botName}'. " f"Write ONLY in the language '{language}'. No quotes, no explanation, just the text to speak.", context="", options=AiCallOptions( operationType=OperationTypeEnum.DATA_ANALYSE, priority=PriorityEnum.SPEED, ) ) aiResponse = await aiService.callAi(aiRequest) testText = aiResponse.content.strip().strip('"').strip("'") if aiResponse and aiResponse.errorCount == 0 else f"Hello, I am {botName}." logger.info(f"Voice test: generated text in {language}: '{testText[:60]}...'") # Convert to speech voiceInterface = getVoiceInterface(context.user, mandateId) result = await voiceInterface.textToSpeech( text=testText, languageCode=language, voiceName=voiceId, ) if result and isinstance(result, dict): import base64 audioContent = result.get("audioContent") if audioContent: audioB64 = base64.b64encode( audioContent if isinstance(audioContent, bytes) else audioContent.encode() ).decode() return { "success": True, "audio": audioB64, "format": "mp3", "language": language, "voiceId": voiceId, "text": testText, } return {"success": False, "error": "TTS returned no audio"} except Exception as e: logger.error(f"Voice test failed: {e}") raise HTTPException(status_code=500, detail=f"TTS-Test fehlgeschlagen: {str(e)}") # ========================================================================= # Browser Bot Communication Endpoints # ========================================================================= @router.websocket("/{instanceId}/bot/ws/{sessionId}") async def botWebsocket( websocket: WebSocket, instanceId: str, sessionId: str, ): """ Bidirectional WebSocket for communication with the Browser Bot. Bot sends: - transcript: Caption text scraped from Teams meeting - status: Bot state changes (joined, in_lobby, left, error) Gateway sends: - playAudio: TTS audio for the bot to play in the meeting """ await websocket.accept() logger.info(f"Browser Bot WebSocket connected: session={sessionId}, instance={instanceId}") # TODO: Validate bot API key from headers/query params try: config = _getInstanceConfig(instanceId) logger.info(f"Browser Bot WebSocket config loaded: session={sessionId}") # Load the original user who started the session (has RBAC roles in mandate) # Bot callbacks have no HTTP auth, so we reconstruct the user context from the session record. from modules.datamodels.datamodelUam import User from modules.interfaces.interfaceDbApp import getRootInterface systemUser = User(id="system", username="system", email="system@poweron.swiss") sessionInterface = interfaceDb.getInterface(systemUser, featureInstanceId=instanceId) session = sessionInterface.getSession(sessionId) mandateId = session.get("mandateId") if session else None startedByUserId = session.get("startedByUserId") if session else None # Look up the original user (getRootInterface uses admin context, can load any user) rootInterface = getRootInterface() originalUser = rootInterface.getUser(startedByUserId) if startedByUserId else None if not originalUser: logger.warning(f"Could not load original user {startedByUserId}, falling back to system user") originalUser = systemUser service = TeamsbotService(originalUser, mandateId, instanceId, config) logger.info(f"Browser Bot WebSocket service created: session={sessionId}, mandateId={mandateId}, user={originalUser.id}") await service.handleBotWebSocket(websocket, sessionId) except WebSocketDisconnect: logger.info(f"Browser Bot WebSocket disconnected: session={sessionId}") except Exception as e: logger.error(f"Browser Bot WebSocket error: session={sessionId}, error={e}", exc_info=True) finally: logger.info(f"Browser Bot WebSocket closed: session={sessionId}")