Latest fixxes

ai_service/api.py

@@ -13,6 +13,7 @@ from datetime import datetime, timezone
 from ai_service.models.model_service import model_service
 from ai_service.models.chat_service import chat_service
 from ai_service.openwebui_api import router as openwebui_router
+from ai_service.openwebui_channels import openwebui_channels
 from ai_service.config import config
 
 # Create FastAPI app
@@ -37,6 +38,27 @@ app.include_router(openwebui_router, prefix="/api")
 # Include Ollama proxy routes
 app.include_router(openwebui_router, prefix="/ollama")
 
+# Register webhook for channel messages on startup
+@app.on_event("startup")
+async def startup_event():
+    """
+    Register webhook for channel messages on startup.
+    """
+    # Get the public URL of this service
+    service_url = f"http://{config.API_HOST}:{config.API_PORT}"
+    if config.PUBLIC_URL:
+        service_url = config.PUBLIC_URL
+
+    # Register webhook
+    webhook_url = f"{service_url}/webhooks/channel-message"
+    print(f"Registering webhook for channel messages: {webhook_url}")
+
+    success = openwebui_channels.register_webhook(webhook_url)
+    if success:
+        print("Successfully registered webhook for channel messages")
+    else:
+        print("Failed to register webhook for channel messages")
+
 # Define API models for health check
 class HealthResponse(BaseModel):
     """Response model for health check."""
@@ -450,3 +472,133 @@ async def delete_chat(chat_id: str):
         raise HTTPException(status_code=404, detail="Chat not found")
 
     return {"status": "success", "message": "Chat deleted"}
+
+# OpenWebUI Channels endpoints
+@app.get("/channels")
+async def get_openwebui_channels():
+    """
+    Get all OpenWebUI channels.
+
+    Returns:
+        List of channels.
+    """
+    channels = openwebui_channels.get_channels()
+    return channels
+
+@app.get("/channels/{channel_id}")
+async def get_openwebui_channel(channel_id: str):
+    """
+    Get an OpenWebUI channel by ID.
+
+    Args:
+        channel_id: Channel ID.
+
+    Returns:
+        Channel information.
+    """
+    channel = openwebui_channels.get_channel(channel_id)
+    if not channel:
+        raise HTTPException(status_code=404, detail="Channel not found")
+
+    return channel
+
+@app.post("/channels")
+async def create_openwebui_channel(name: str, description: str = "", is_private: bool = False):
+    """
+    Create a new OpenWebUI channel.
+
+    Args:
+        name: Channel name.
+        description: Channel description.
+        is_private: Whether the channel is private.
+
+    Returns:
+        Created channel.
+    """
+    channel = openwebui_channels.create_channel(name, description, is_private)
+    if not channel:
+        raise HTTPException(status_code=400, detail="Failed to create channel")
+
+    return channel
+
+# Webhook endpoint for OpenWebUI channel messages
+class ChannelMessageWebhook(BaseModel):
+    """Model for channel message webhook."""
+    channel_id: str = Field(..., description="Channel ID")
+    message: str = Field(..., description="Message content")
+    user_id: str = Field(..., description="User ID")
+    timestamp: Optional[str] = Field(None, description="Message timestamp")
+
+@app.post("/webhooks/channel-message")
+async def channel_message_webhook(request: ChannelMessageWebhook):
+    """
+    Webhook endpoint for receiving messages from OpenWebUI channels.
+
+    This endpoint is called by OpenWebUI when a message is sent in a channel.
+    The AI service will process the message and respond in the channel.
+
+    Args:
+        request: Channel message webhook request.
+
+    Returns:
+        Processing status.
+    """
+    try:
+        print(f"Received channel message webhook: {request.channel_id}, {request.user_id}, {request.message}")
+
+        # Find the chat associated with this OpenWebUI channel
+        chat_id = None
+        for cid, chat in chat_service.chats.items():
+            if chat.get('is_team_chat') and chat.get('openwebui_channel_id') == request.channel_id:
+                chat_id = cid
+                break
+
+        if not chat_id:
+            print(f"No chat found for OpenWebUI channel {request.channel_id}")
+            return {"status": "error", "message": "No chat found for this channel"}
+
+        # Skip messages from the AI assistant to avoid loops
+        if request.user_id == "ai-assistant":
+            return {"status": "skipped", "message": "Skipping AI assistant message"}
+
+        # Check if we should respond to all messages or only to mentions
+        if not config.AI_RESPOND_TO_ALL:
+            # Check if the message mentions the AI using configured triggers
+            message_lower = request.message.lower()
+
+            is_triggered = False
+            for trigger in config.AI_TRIGGERS:
+                if trigger.lower() in message_lower:
+                    is_triggered = True
+                    break
+
+            # If no trigger is found, skip processing
+            if not is_triggered:
+                print(f"No AI mention found in message, skipping: {request.message[:50]}...")
+                return {"status": "skipped", "message": "No AI mention found in message"}
+
+        # Extract the actual message content (remove the trigger)
+        # This is a simple approach - for more complex cases, you might want more sophisticated parsing
+        processed_message = request.message
+        message_lower = request.message.lower()
+
+        # Only try to remove triggers if we're not responding to all messages
+        if not config.AI_RESPOND_TO_ALL:
+            for trigger in config.AI_TRIGGERS:
+                if trigger.lower() in message_lower:
+                    # Remove the trigger from the message
+                    processed_message = request.message.replace(trigger, "").strip()
+                    break
+
+        # Process the message and generate a response
+        response = chat_service.get_chat_response(
+            chat_id=chat_id,
+            message=processed_message,
+            user_id=request.user_id
+        )
+
+        return {"status": "success", "message": "Message processed", "response": response}
+
+    except Exception as e:
+        print(f"Error processing channel message webhook: {str(e)}")
+        return {"status": "error", "message": f"Error processing message: {str(e)}"}