From 7369b6c25f2b950d6cff32ac0a9e91b305cc5622 Mon Sep 17 00:00:00 2001
From: Russell Ballestrini <russell.ballestrini@coursemojo.com>
Date: Wed, 6 Dec 2023 12:16:35 -0500
Subject: [PATCH] reorder 	modified:   app.py

---
 app.py | 1031 ++++++++++++++++++++++++++++----------------------------
 1 file changed, 515 insertions(+), 516 deletions(-)

diff --git a/app.py b/app.py
index b630984..cbb1885 100644
--- a/app.py
+++ b/app.py
@@ -138,6 +138,521 @@ def on_join(data):
     )
 
 
+@socketio.on("message")
+def handle_message(data):
+    room_name = data["room_name"]
+    room = get_room(room_name)
+
+    # Save the message to the database
+    new_message = Message(
+        username=data["username"],
+        content=data["message"],
+        room_id=room.id,
+    )
+    db.session.add(new_message)
+    db.session.commit()
+
+    emit(
+        "message",
+        {
+            "id": new_message.id,
+            "username": data["username"],
+            "content": data["message"],
+        },
+        room=room.name,
+    )
+
+    # detect and process special commands.
+    commands = data["message"].splitlines()
+
+    for command in commands:
+        if command.startswith("/s3 ls"):
+            # Extract the S3 file path pattern
+            s3_file_path_pattern = command.split(" ", 2)[2]
+            # List files from S3 and emit their names
+            eventlet.spawn(
+                list_s3_files, room.name, s3_file_path_pattern, data["username"]
+            )
+        if command.startswith("/s3 load"):
+            # Extract the S3 file path
+            s3_file_path = command.split(" ", 2)[2]
+            # Load the file from S3 and emit its content
+            eventlet.spawn(load_s3_file, room_name, s3_file_path, data["username"])
+        if command.startswith("/s3 save"):
+            # Extract the S3 key path
+            s3_key_path = command.split(" ", 2)[2]
+            # Save the most recent code block to S3
+            eventlet.spawn(
+                save_code_block_to_s3, room_name, s3_key_path, data["username"]
+            )
+        if command.startswith("/title new"):
+            eventlet.spawn(generate_new_title, room_name, data["username"])
+        if command.startswith("/cancel"):
+            # Cancel the most recent generation request
+            eventlet.spawn(cancel_generation, room_name, data["username"])
+
+    if "dall-e-3" in data["message"]:
+        # Use the entire message as the prompt for DALL-E 3
+        # Generate the image and emit its URL
+        eventlet.spawn(
+            generate_dalle_image, data["room_name"], data["message"], data["username"]
+        )
+
+    if (
+        "claude-v1" in data["message"]
+        or "claude-v2" in data["message"]
+        or "gpt-3" in data["message"]
+        or "gpt-4" in data["message"]
+    ):
+        # Emit a temporary message indicating that llm is processing
+        emit(
+            "message",
+            {"id": None, "content": f"<span id='processing'>Processing...</span>"},
+            room=room.name,
+        )
+
+        if "claude-v1" in data["message"]:
+            eventlet.spawn(chat_claude, data["username"], room.name, data["message"])
+        if "claude-v2" in data["message"]:
+            eventlet.spawn(
+                chat_claude,
+                data["username"],
+                room.name,
+                data["message"],
+                model_name="anthropic.claude-v2",
+            )
+        if "gpt-3" in data["message"]:
+            eventlet.spawn(chat_gpt, data["username"], room.name, data["message"])
+        if "gpt-4" in data["message"]:
+            eventlet.spawn(
+                chat_gpt,
+                data["username"],
+                room.name,
+                data["message"],
+                model_name="gpt-4-1106-preview",
+            )
+
+
+@socketio.on("delete_message")
+def handle_delete_message(data):
+    msg_id = data["message_id"]
+    # Delete the message from the database
+    message = db.session.query(Message).filter(Message.id == msg_id).one_or_none()
+    if message:
+        db.session.delete(message)
+        db.session.commit()
+
+    # Notify all clients in the room to remove the message from their DOM
+    emit("message_deleted", {"message_id": msg_id}, room=data["room_name"])
+
+
+def chat_claude(username, room_name, message, model_name="anthropic.claude-v1"):
+    with app.app_context():
+        room = get_room(room_name)
+        # claude has a 100,000 token context window for prompts.
+        all_messages = (
+            Message.query.filter_by(room_id=room.id).order_by(Message.id.desc()).all()
+        )
+
+    chat_history = ""
+
+    def is_base64_image(content):
+        return '<img src="data:image/jpeg;base64,' in content
+
+    for msg in reversed(all_messages):
+        if is_base64_image(msg.content):
+            continue
+        if msg.username in [
+            "gpt-3.5-turbo",
+            "anthropic.claude-v1",
+            "anthropic.claude-v2",
+            "gpt-4",
+            "gpt-4-1106-preview",
+        ]:
+            chat_history += f"Assistant: {msg.username}: {msg.content}\n\n"
+        else:
+            chat_history += f"Human: {msg.username}: {msg.content}\n\n"
+
+    # append the new message.
+    chat_history += f"Human: {username}: {message}\n\nAssistant: {model_name}: "
+
+    # Initialize the Bedrock client using boto3 and profile name.
+    if app.config.get("PROFILE_NAME"):
+        session = boto3.Session(profile_name=app.config["PROFILE_NAME"])
+        client = session.client("bedrock-runtime", region_name="us-east-1")
+    else:
+        client = boto3.client("bedrock-runtime", region_name="us-east-1")
+
+    # Define the request parameters
+    params = {
+        "modelId": model_name,
+        "contentType": "application/json",
+        "accept": "*/*",
+        "body": json.dumps(
+            {
+                "prompt": chat_history,
+                "max_tokens_to_sample": 2048,
+                "temperature": 0,
+                "top_k": 250,
+                "top_p": 0.999,
+                "stop_sequences": ["\n\nHuman:"],
+                "anthropic_version": "bedrock-2023-05-31",
+            }
+        ).encode(),
+    }
+
+    # Process the event stream
+    buffer = ""
+
+    # save empty message, we need the ID when we chunk the response.
+    with app.app_context():
+        new_message = Message(username=model_name, content=buffer, room_id=room.id)
+        db.session.add(new_message)
+        db.session.commit()
+        msg_id = new_message.id
+
+    try:
+        # Invoke the model with response stream
+        response = client.invoke_model_with_response_stream(**params)["body"]
+
+        cancellation_requests[msg_id] = False
+
+        first_chunk = True
+        for event in response:
+            content = ""
+
+            # Check if there has been a cancellation request, break if there is.
+            if cancellation_requests.get(msg_id):
+                del cancellation_requests[msg_id]
+                break
+
+            if "chunk" in event:
+                chunk_data = json.loads(event["chunk"]["bytes"].decode())
+                content = chunk_data["completion"]
+
+            if content:
+                buffer += content  # Accumulate content
+
+                if first_chunk:
+                    socketio.emit(
+                        "message_chunk",
+                        {
+                            "id": msg_id,
+                            "content": f"**{username} ({model_name}):**\n\n{content}",
+                        },
+                        room=room.name,
+                    )
+                    first_chunk = False
+                else:
+                    socketio.emit(
+                        "message_chunk",
+                        {"id": msg_id, "content": content},
+                        room=room.name,
+                    )
+                socketio.sleep(0)  # Force immediate handling
+
+    except Exception as e:
+        with app.app_context():
+            message_content = f"AWS Bedrock Error: {e}"
+            new_message = (
+                db.session.query(Message).filter(Message.id == msg_id).one_or_none()
+            )
+            if new_message:
+                new_message.content = message_content
+                db.session.add(new_message)
+                db.session.commit()
+        socketio.emit(
+            "message",
+            {
+                "id": msg_id,
+                "username": model_name,
+                "content": message_content,
+            },
+            room=room_name,
+        )
+        socketio.emit("delete_processing_message", msg_id, room=room.name)
+        # exit early to avoid clobbering the error message.
+        return None
+
+    # Save the entire completion to the database
+    with app.app_context():
+        new_message = (
+            db.session.query(Message).filter(Message.id == msg_id).one_or_none()
+        )
+        if new_message:
+            new_message.content = buffer
+            db.session.add(new_message)
+            db.session.commit()
+
+    socketio.emit("delete_processing_message", msg_id, room=room.name)
+
+
+def chat_gpt(username, room_name, message, model_name="gpt-3.5-turbo"):
+    openai_client = OpenAI()
+    limit = 15
+    if model_name == "gpt-4-1106-preview":
+        limit = 1000
+
+    with app.app_context():
+        room = get_room(room_name)
+        last_messages = (
+            Message.query.filter_by(room_id=room.id)
+            .order_by(Message.id.desc())
+            .limit(limit)
+            .all()
+        )
+        if room.title is None and len(last_messages) >= 5:
+            room.title = gpt_generate_room_title(last_messages, model_name)
+            db.session.add(room)
+            db.session.commit()
+            socketio.emit("update_room_title", {"title": room.title}, room=room.name)
+            # Emit an event to update this rooms title in the sidebar for all users.
+            updated_room_data = {"id": room.id, "name": room.name, "title": room.title}
+            socketio.emit("update_room_list", updated_room_data, room=None)
+
+        def is_base64_image(content):
+            return '<img src="data:image/jpeg;base64,' in content
+
+        chat_history = [
+            {
+                "role": "system"
+                if (
+                    msg.username == "gpt-3.5-turbo"
+                    or msg.username == "anthropic.claude-v1"
+                    or msg.username == "anthropic.claude-v2"
+                    or msg.username == "gpt-4"
+                    or msg.username == "gpt-4-1106-preview"
+                )
+                else "user",
+                "content": f"{msg.username}: {msg.content}",
+            }
+            for msg in reversed(last_messages)
+            if not is_base64_image(msg.content)
+        ]
+
+        chat_history.append({"role": "user", "content": f"{message}\n\n{model_name}: "})
+
+    buffer = ""  # Content buffer for accumulating the chunks
+
+    # save empty message, we need the ID when we chunk the response.
+    with app.app_context():
+        new_message = Message(username=model_name, content=buffer, room_id=room.id)
+        db.session.add(new_message)
+        db.session.commit()
+        msg_id = new_message.id
+
+    cancellation_requests[msg_id] = False
+
+    first_chunk = True
+
+    try:
+        chunks = openai_client.chat.completions.create(
+            model=model_name, messages=chat_history, temperature=0, stream=True
+        )
+    except Exception as e:
+        with app.app_context():
+            message_content = f"OpenAi Error: {e}"
+            new_message = (
+                db.session.query(Message).filter(Message.id == msg_id).one_or_none()
+            )
+            if new_message:
+                new_message.content = message_content
+                db.session.add(new_message)
+                db.session.commit()
+        socketio.emit(
+            "message",
+            {
+                "id": msg_id,
+                "username": model_name,
+                "content": message_content,
+            },
+            room=room_name,
+        )
+        socketio.emit("delete_processing_message", msg_id, room=room.name)
+        # exit early to avoid clobbering the error message.
+        return None
+
+    for chunk in chunks:
+        # Check if there has been a cancellation request, break if there is.
+        if cancellation_requests.get(msg_id):
+            del cancellation_requests[msg_id]
+            break
+
+        content = chunk.choices[0].delta.content
+
+        if content:
+            buffer += content  # Accumulate content
+
+            if first_chunk:
+                socketio.emit(
+                    "message_chunk",
+                    {
+                        "id": msg_id,
+                        "content": f"**{username} ({model_name}):**\n\n{content}",
+                    },
+                    room=room.name,
+                )
+                first_chunk = False
+            else:
+                socketio.emit(
+                    "message_chunk",
+                    {"id": msg_id, "content": content},
+                    room=room.name,
+                )
+            socketio.sleep(0)  # Force immediate handling
+
+    # Save the entire completion to the database
+    with app.app_context():
+        new_message = (
+            db.session.query(Message).filter(Message.id == msg_id).one_or_none()
+        )
+        if new_message:
+            new_message.content = buffer
+            db.session.add(new_message)
+            db.session.commit()
+
+    socketio.emit("delete_processing_message", msg_id, room=room.name)
+
+
+def gpt_generate_room_title(messages, model_name):
+    """
+    Generate a title for the room based on a list of messages.
+    """
+    openai_client = OpenAI()
+
+    def is_base64_image(content):
+        return '<img src="data:image/jpeg;base64,' in content
+
+    chat_history = [
+        {
+            "role": "system"
+            if (
+                msg.username == "gpt-3.5-turbo"
+                or msg.username == "anthropic.claude-v1"
+                or msg.username == "anthropic.claude-v2"
+                or msg.username == "gpt-4"
+                or msg.username == "gpt-4-1106-preview"
+            )
+            else "user",
+            "content": f"{msg.username}: {msg.content}",
+        }
+        for msg in reversed(messages)
+        if not is_base64_image(msg.content)
+    ]
+
+    chat_history.append(
+        {
+            "role": "system",
+            "content": "return a short title for the title bar of this conversation.",
+        }
+    )
+
+    # Interaction with LLM to generate summary
+    # For example, using OpenAI's GPT model
+    response = openai_client.chat.completions.create(
+        messages=chat_history,
+        model=model_name,  # or any appropriate model
+        max_tokens=20,
+    )
+
+    title = response.choices[0].message.content
+    return title.replace('"', "")
+
+
+def generate_new_title(room_name, username):
+    with app.app_context():
+        room = get_room(room_name)
+        # Get the last few messages to generate a title
+        last_messages = (
+            Message.query.filter_by(room_id=room.id)
+            .order_by(Message.id.desc())
+            .limit(100)  # Adjust the limit as needed
+            .all()
+        )
+
+        # Generate the title using the messages
+        new_title = gpt_generate_room_title(last_messages, "gpt-4-1106-preview")
+
+        # Update the room title in the database
+        room.title = new_title
+        db.session.add(room)
+        db.session.commit()
+
+        # Emit the new title to the room.
+        socketio.emit("update_room_title", {"title": new_title}, room=room_name)
+
+        # Emit an event to update this rooms title in the sidebar for all users.
+        updated_room_data = {"id": room.id, "name": room.name, "title": room.title}
+        socketio.emit("update_room_list", updated_room_data, room=None)
+
+        # Optionally, send a confirmation message to the room
+        confirmation_message = f"New title created: {new_title}"
+        new_message = Message(
+            username=username, content=confirmation_message, room_id=room.id
+        )
+        db.session.add(new_message)
+        db.session.commit()
+        socketio.emit(
+            "message",
+            {
+                "id": new_message.id,
+                "username": username,
+                "content": confirmation_message,
+            },
+            room=room_name,
+        )
+
+
+def generate_dalle_image(room_name, message, username):
+    socketio.emit(
+        "message",
+        {"id": None, "content": "Processing..."},
+        room=room_name,
+    )
+
+    openai_client = OpenAI()
+    # Initialize the content variable to hold either the image tag or an error message
+    content = ""
+    try:
+        # Call the DALL-E 3 API to generate an image in base64 format
+        response = openai_client.images.generate(
+            model="dall-e-3",
+            prompt=message,
+            n=1,
+            size="1024x1024",
+            response_format="b64_json",
+        )
+
+        # Access the base64-encoded image data
+        image_data = response.data[0].b64_json
+        revised_prompt = response.data[0].revised_prompt
+
+        # Create an HTML img tag with the base64 data
+        content = f'<img src="data:image/jpeg;base64,{image_data}" alt="{message}"><p>{revised_prompt}</p>'
+
+    except Exception as e:
+        # Set the content to an error message
+        content = f"Error generating image: {e}"
+
+    # Store the content in the database and emit to the frontend
+    with app.app_context():
+        room = get_room(room_name)
+        new_message = Message(
+            username=username,
+            content=content,  # Store the img tag or error message as the content
+            room_id=room.id,  # Make sure you have the room ID available
+        )
+        db.session.add(new_message)
+        db.session.commit()
+
+        # Emit the message with the content to the frontend
+        socketio.emit(
+            "message",
+            {"id": new_message.id, "username": username, "content": content},
+            room=room_name,
+        )
+
+
 def find_most_recent_code_block(room_name):
     with app.app_context():
         # Get the room object from the database
@@ -385,522 +900,6 @@ def cancel_generation(room_name, username):
         )
 
 
-@socketio.on("message")
-def handle_message(data):
-    room_name = data["room_name"]
-    room = get_room(room_name)
-
-    # Save the message to the database
-    new_message = Message(
-        username=data["username"],
-        content=data["message"],
-        room_id=room.id,
-    )
-    db.session.add(new_message)
-    db.session.commit()
-
-    emit(
-        "message",
-        {
-            "id": new_message.id,
-            "username": data["username"],
-            "content": data["message"],
-        },
-        room=room.name,
-    )
-
-    # detect and process special commands.
-    commands = data["message"].splitlines()
-
-    for command in commands:
-        if command.startswith("/s3 ls"):
-            # Extract the S3 file path pattern
-            s3_file_path_pattern = command.split(" ", 2)[2]
-            # List files from S3 and emit their names
-            eventlet.spawn(
-                list_s3_files, room.name, s3_file_path_pattern, data["username"]
-            )
-        if command.startswith("/s3 load"):
-            # Extract the S3 file path
-            s3_file_path = command.split(" ", 2)[2]
-            # Load the file from S3 and emit its content
-            eventlet.spawn(load_s3_file, room_name, s3_file_path, data["username"])
-        if command.startswith("/s3 save"):
-            # Extract the S3 key path
-            s3_key_path = command.split(" ", 2)[2]
-            # Save the most recent code block to S3
-            eventlet.spawn(
-                save_code_block_to_s3, room_name, s3_key_path, data["username"]
-            )
-        if command.startswith("/title new"):
-            eventlet.spawn(generate_new_title, room_name, data["username"])
-        if command.startswith("/cancel"):
-            # Cancel the most recent generation request
-            eventlet.spawn(cancel_generation, room_name, data["username"])
-
-    if "dall-e-3" in data["message"]:
-        # Use the entire message as the prompt for DALL-E 3
-        # Generate the image and emit its URL
-        eventlet.spawn(
-            generate_dalle_image, data["room_name"], data["message"], data["username"]
-        )
-
-    if (
-        "claude-v1" in data["message"]
-        or "claude-v2" in data["message"]
-        or "gpt-3" in data["message"]
-        or "gpt-4" in data["message"]
-    ):
-        # Emit a temporary message indicating that llm is processing
-        emit(
-            "message",
-            {"id": None, "content": f"<span id='processing'>Processing...</span>"},
-            room=room.name,
-        )
-
-        if "claude-v1" in data["message"]:
-            eventlet.spawn(chat_claude, data["username"], room.name, data["message"])
-        if "claude-v2" in data["message"]:
-            eventlet.spawn(
-                chat_claude,
-                data["username"],
-                room.name,
-                data["message"],
-                model_name="anthropic.claude-v2",
-            )
-        if "gpt-3" in data["message"]:
-            eventlet.spawn(chat_gpt, data["username"], room.name, data["message"])
-        if "gpt-4" in data["message"]:
-            eventlet.spawn(
-                chat_gpt,
-                data["username"],
-                room.name,
-                data["message"],
-                model_name="gpt-4-1106-preview",
-            )
-
-
-@socketio.on("delete_message")
-def handle_delete_message(data):
-    msg_id = data["message_id"]
-    # Delete the message from the database
-    message = db.session.query(Message).filter(Message.id == msg_id).one_or_none()
-    if message:
-        db.session.delete(message)
-        db.session.commit()
-
-    # Notify all clients in the room to remove the message from their DOM
-    emit("message_deleted", {"message_id": msg_id}, room=data["room_name"])
-
-
-def chat_claude(username, room_name, message, model_name="anthropic.claude-v1"):
-    with app.app_context():
-        room = get_room(room_name)
-        # claude has a 100,000 token context window for prompts.
-        all_messages = (
-            Message.query.filter_by(room_id=room.id).order_by(Message.id.desc()).all()
-        )
-
-    chat_history = ""
-
-    def is_base64_image(content):
-        return "<img src=\"data:image/jpeg;base64," in content
-
-    for msg in reversed(all_messages):
-        if is_base64_image(msg.content):
-            continue
-        if msg.username in [
-            "gpt-3.5-turbo",
-            "anthropic.claude-v1",
-            "anthropic.claude-v2",
-            "gpt-4",
-            "gpt-4-1106-preview",
-        ]:
-            chat_history += f"Assistant: {msg.username}: {msg.content}\n\n"
-        else:
-            chat_history += f"Human: {msg.username}: {msg.content}\n\n"
-
-    # append the new message.
-    chat_history += f"Human: {username}: {message}\n\nAssistant: {model_name}: "
-
-    # Initialize the Bedrock client using boto3 and profile name.
-    if app.config.get("PROFILE_NAME"):
-        session = boto3.Session(profile_name=app.config["PROFILE_NAME"])
-        client = session.client("bedrock-runtime", region_name="us-east-1")
-    else:
-        client = boto3.client("bedrock-runtime", region_name="us-east-1")
-
-    # Define the request parameters
-    params = {
-        "modelId": model_name,
-        "contentType": "application/json",
-        "accept": "*/*",
-        "body": json.dumps(
-            {
-                "prompt": chat_history,
-                "max_tokens_to_sample": 2048,
-                "temperature": 0,
-                "top_k": 250,
-                "top_p": 0.999,
-                "stop_sequences": ["\n\nHuman:"],
-                "anthropic_version": "bedrock-2023-05-31",
-            }
-        ).encode(),
-    }
-
-    # Process the event stream
-    buffer = ""
-
-    # save empty message, we need the ID when we chunk the response.
-    with app.app_context():
-        new_message = Message(username=model_name, content=buffer, room_id=room.id)
-        db.session.add(new_message)
-        db.session.commit()
-        msg_id = new_message.id
-
-    try:
-        # Invoke the model with response stream
-        response = client.invoke_model_with_response_stream(**params)["body"]
-
-        cancellation_requests[msg_id] = False
-
-        first_chunk = True
-        for event in response:
-            content = ""
-
-            # Check if there has been a cancellation request, break if there is.
-            if cancellation_requests.get(msg_id):
-                del cancellation_requests[msg_id]
-                break
-
-            if "chunk" in event:
-                chunk_data = json.loads(event["chunk"]["bytes"].decode())
-                content = chunk_data["completion"]
-
-            if content:
-                buffer += content  # Accumulate content
-
-                if first_chunk:
-                    socketio.emit(
-                        "message_chunk",
-                        {
-                            "id": msg_id,
-                            "content": f"**{username} ({model_name}):**\n\n{content}",
-                        },
-                        room=room.name,
-                    )
-                    first_chunk = False
-                else:
-                    socketio.emit(
-                        "message_chunk",
-                        {"id": msg_id, "content": content},
-                        room=room.name,
-                    )
-                socketio.sleep(0)  # Force immediate handling
-
-    except Exception as e:
-        with app.app_context():
-            message_content = f"AWS Bedrock Error: {e}"
-            new_message = (
-                db.session.query(Message).filter(Message.id == msg_id).one_or_none()
-            )
-            if new_message:
-                new_message.content = message_content
-                db.session.add(new_message)
-                db.session.commit()
-        socketio.emit(
-            "message",
-            {
-                "id": msg_id,
-                "username": model_name,
-                "content": message_content,
-            },
-            room=room_name,
-        )
-        socketio.emit("delete_processing_message", msg_id, room=room.name)
-        # exit early to avoid clobbering the error message.
-        return None    
-
-    # Save the entire completion to the database
-    with app.app_context():
-        new_message = (
-            db.session.query(Message).filter(Message.id == msg_id).one_or_none()
-        )
-        if new_message:
-            new_message.content = buffer
-            db.session.add(new_message)
-            db.session.commit()
-
-    socketio.emit("delete_processing_message", msg_id, room=room.name)
-
-
-def chat_gpt(username, room_name, message, model_name="gpt-3.5-turbo"):
-    openai_client = OpenAI()
-    limit = 15
-    if model_name == "gpt-4-1106-preview":
-        limit = 1000
-
-    with app.app_context():
-        room = get_room(room_name)
-        last_messages = (
-            Message.query.filter_by(room_id=room.id)
-            .order_by(Message.id.desc())
-            .limit(limit)
-            .all()
-        )
-        if room.title is None and len(last_messages) >= 5:
-            room.title = gpt_generate_room_title(last_messages, model_name)
-            db.session.add(room)
-            db.session.commit()
-            socketio.emit("update_room_title", {"title": room.title}, room=room.name)
-            # Emit an event to update this rooms title in the sidebar for all users.
-            updated_room_data = {"id": room.id, "name": room.name, "title": room.title}
-            socketio.emit("update_room_list", updated_room_data, room=None)
-
-        def is_base64_image(content):
-            return "<img src=\"data:image/jpeg;base64," in content
-
-        chat_history = [
-            {
-                "role": "system"
-                if (
-                    msg.username == "gpt-3.5-turbo"
-                    or msg.username == "anthropic.claude-v1"
-                    or msg.username == "anthropic.claude-v2"
-                    or msg.username == "gpt-4"
-                    or msg.username == "gpt-4-1106-preview"
-                )
-                else "user",
-                "content": f"{msg.username}: {msg.content}",
-            }
-            for msg in reversed(last_messages)
-            if not is_base64_image(msg.content)
-        ]
-
-        chat_history.append({"role": "user", "content": f"{message}\n\n{model_name}: "})
-
-    buffer = ""  # Content buffer for accumulating the chunks
-
-    # save empty message, we need the ID when we chunk the response.
-    with app.app_context():
-        new_message = Message(username=model_name, content=buffer, room_id=room.id)
-        db.session.add(new_message)
-        db.session.commit()
-        msg_id = new_message.id
-
-    cancellation_requests[msg_id] = False
-
-    first_chunk = True
-
-    try:
-        chunks = openai_client.chat.completions.create(
-            model=model_name, messages=chat_history, temperature=0, stream=True
-        )
-    except Exception as e:
-        with app.app_context():
-            message_content = f"OpenAi Error: {e}"
-            new_message = (
-                db.session.query(Message).filter(Message.id == msg_id).one_or_none()
-            )
-            if new_message:
-                new_message.content = message_content
-                db.session.add(new_message)
-                db.session.commit()
-        socketio.emit(
-            "message",
-            {
-                "id": msg_id,
-                "username": model_name,
-                "content": message_content,
-            },
-            room=room_name,
-        )
-        socketio.emit("delete_processing_message", msg_id, room=room.name)
-        # exit early to avoid clobbering the error message.
-        return None
-
-    for chunk in chunks:
-        # Check if there has been a cancellation request, break if there is.
-        if cancellation_requests.get(msg_id):
-            del cancellation_requests[msg_id]
-            break
-
-        content = chunk.choices[0].delta.content
-
-        if content:
-            buffer += content  # Accumulate content
-
-            if first_chunk:
-                socketio.emit(
-                    "message_chunk",
-                    {
-                        "id": msg_id,
-                        "content": f"**{username} ({model_name}):**\n\n{content}",
-                    },
-                    room=room.name,
-                )
-                first_chunk = False
-            else:
-                socketio.emit(
-                    "message_chunk",
-                    {"id": msg_id, "content": content},
-                    room=room.name,
-                )
-            socketio.sleep(0)  # Force immediate handling
-
-    # Save the entire completion to the database
-    with app.app_context():
-        new_message = (
-            db.session.query(Message).filter(Message.id == msg_id).one_or_none()
-        )
-        if new_message:
-            new_message.content = buffer
-            db.session.add(new_message)
-            db.session.commit()
-
-    socketio.emit("delete_processing_message", msg_id, room=room.name)
-
-
-def gpt_generate_room_title(messages, model_name):
-    """
-    Generate a title for the room based on a list of messages.
-    """
-    openai_client = OpenAI()
-
-    def is_base64_image(content):
-        return "<img src=\"data:image/jpeg;base64," in content
-
-
-    chat_history = [
-        {
-            "role": "system"
-            if (
-                msg.username == "gpt-3.5-turbo"
-                or msg.username == "anthropic.claude-v1"
-                or msg.username == "anthropic.claude-v2"
-                or msg.username == "gpt-4"
-                or msg.username == "gpt-4-1106-preview"
-            )
-            else "user",
-            "content": f"{msg.username}: {msg.content}",
-        }
-        for msg in reversed(messages)
-        if not is_base64_image(msg.content)
-    ]
-
-    chat_history.append(
-        {
-            "role": "system",
-            "content": "return a short title for the title bar of this conversation.",
-        }
-    )
-
-    # Interaction with LLM to generate summary
-    # For example, using OpenAI's GPT model
-    response = openai_client.chat.completions.create(
-        messages=chat_history,
-        model=model_name,  # or any appropriate model
-        max_tokens=20,
-    )
-
-    title = response.choices[0].message.content
-    return title.replace('"', "")
-
-
-def generate_new_title(room_name, username):
-    with app.app_context():
-        room = get_room(room_name)
-        # Get the last few messages to generate a title
-        last_messages = (
-            Message.query.filter_by(room_id=room.id)
-            .order_by(Message.id.desc())
-            .limit(100)  # Adjust the limit as needed
-            .all()
-        )
-
-        # Generate the title using the messages
-        new_title = gpt_generate_room_title(last_messages, "gpt-4-1106-preview")
-
-        # Update the room title in the database
-        room.title = new_title
-        db.session.add(room)
-        db.session.commit()
-
-        # Emit the new title to the room.
-        socketio.emit("update_room_title", {"title": new_title}, room=room_name)
-
-        # Emit an event to update this rooms title in the sidebar for all users.
-        updated_room_data = {"id": room.id, "name": room.name, "title": room.title}
-        socketio.emit("update_room_list", updated_room_data, room=None)
-
-        # Optionally, send a confirmation message to the room
-        confirmation_message = f"New title created: {new_title}"
-        new_message = Message(
-            username=username, content=confirmation_message, room_id=room.id
-        )
-        db.session.add(new_message)
-        db.session.commit()
-        socketio.emit(
-            "message",
-            {
-                "id": new_message.id,
-                "username": username,
-                "content": confirmation_message,
-            },
-            room=room_name,
-        )
-
-
-def generate_dalle_image(room_name, message, username):
-    socketio.emit(
-        "message",
-        {"id": None, "content": "Processing..."},
-        room=room_name,
-    )
-
-    openai_client = OpenAI()
-    # Initialize the content variable to hold either the image tag or an error message
-    content = ""
-    try:
-        # Call the DALL-E 3 API to generate an image in base64 format
-        response = openai_client.images.generate(
-            model="dall-e-3",
-            prompt=message,
-            n=1,
-            size="1024x1024",
-            response_format="b64_json",
-        )
-
-        # Access the base64-encoded image data
-        image_data = response.data[0].b64_json
-        revised_prompt = response.data[0].revised_prompt
-
-        # Create an HTML img tag with the base64 data
-        content = f'<img src="data:image/jpeg;base64,{image_data}" alt="{message}"><p>{revised_prompt}</p>'
-
-    except Exception as e:
-        # Set the content to an error message
-        content = f"Error generating image: {e}"
-
-    # Store the content in the database and emit to the frontend
-    with app.app_context():
-        room = get_room(room_name)
-        new_message = Message(
-            username=username,
-            content=content,  # Store the img tag or error message as the content
-            room_id=room.id,  # Make sure you have the room ID available
-        )
-        db.session.add(new_message)
-        db.session.commit()
-
-        # Emit the message with the content to the frontend
-        socketio.emit(
-            "message",
-            {"id": new_message.id, "username": username, "content": content},
-            room=room_name,
-        )
-
-
 if __name__ == "__main__":
     import argparse