chainlit 1.0.506__py3-none-any.whl → 1.1.0__py3-none-any.whl

chainlit/data/__init__.py

@@ -156,6 +156,7 @@ class ChainlitDataLayer(BaseDataLayer):
             "chainlitKey": None,
             "display": metadata.get("display", "side"),
             "language": metadata.get("language"),
+            "autoPlay": metadata.get("autoPlay", None),
             "page": metadata.get("page"),
             "size": metadata.get("size"),
             "type": metadata.get("type", "file"),
@@ -219,7 +220,7 @@ class ChainlitDataLayer(BaseDataLayer):
             "disableFeedback": metadata.get("disableFeedback", False),
             "indent": metadata.get("indent"),
             "language": metadata.get("language"),
-            "isError": metadata.get("isError", False),
+            "isError": bool(step.error),
             "waitForAnswer": metadata.get("waitForAnswer", False),
         }
 
@@ -348,7 +349,6 @@ class ChainlitDataLayer(BaseDataLayer):
             step_dict.get("metadata", {}),
             **{
                 "disableFeedback": step_dict.get("disableFeedback"),
-                "isError": step_dict.get("isError"),
                 "waitForAnswer": step_dict.get("waitForAnswer"),
                 "language": step_dict.get("language"),
                 "showInput": step_dict.get("showInput"),
@@ -372,6 +372,8 @@ class ChainlitDataLayer(BaseDataLayer):
             step["input"] = {"content": step_dict.get("input")}
         if step_dict.get("output"):
             step["output"] = {"content": step_dict.get("output")}
+        if step_dict.get("isError"):
+            step["error"] = step_dict.get("output")
 
         await self.client.api.send_steps([step])
 

chainlit/data/acl.py

@@ -5,9 +5,12 @@ from fastapi import HTTPException
 async def is_thread_author(username: str, thread_id: str):
     data_layer = get_data_layer()
     if not data_layer:
-        raise HTTPException(status_code=401, detail="Unauthorized")
+        raise HTTPException(status_code=400, detail="Data layer not initialized")
 
     thread_author = await data_layer.get_thread_author(thread_id)
+    
+    if not thread_author:
+        raise HTTPException(status_code=404, detail="Thread not found")
 
     if thread_author != username:
         raise HTTPException(status_code=401, detail="Unauthorized")

chainlit/data/sql_alchemy.py

@@ -39,9 +39,11 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         ssl_require: bool = False,
         storage_provider: Optional[BaseStorageClient] = None,
         user_thread_limit: Optional[int] = 1000,
+        show_logger: Optional[bool] = False,
     ):
         self._conninfo = conninfo
         self.user_thread_limit = user_thread_limit
+        self.show_logger = show_logger
         ssl_args = {}
         if ssl_require:
             # Create an SSL context to require an SSL connection
@@ -55,7 +57,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         self.async_session = sessionmaker(bind=self.engine, expire_on_commit=False, class_=AsyncSession)  # type: ignore
         if storage_provider:
             self.storage_provider: Optional[BaseStorageClient] = storage_provider
-            logger.info("SQLAlchemyDataLayer storage client initialized")
+            if self.show_logger: logger.info("SQLAlchemyDataLayer storage client initialized")
         else:
             self.storage_provider = None
             logger.warn(
@@ -102,7 +104,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
 
     ###### User ######
     async def get_user(self, identifier: str) -> Optional[PersistedUser]:
-        logger.info(f"SQLAlchemy: get_user, identifier={identifier}")
+        if self.show_logger: logger.info(f"SQLAlchemy: get_user, identifier={identifier}")
         query = "SELECT * FROM users WHERE identifier = :identifier"
         parameters = {"identifier": identifier}
         result = await self.execute_sql(query=query, parameters=parameters)
@@ -112,20 +114,20 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         return None
 
     async def create_user(self, user: User) -> Optional[PersistedUser]:
-        logger.info(f"SQLAlchemy: create_user, user_identifier={user.identifier}")
+        if self.show_logger: logger.info(f"SQLAlchemy: create_user, user_identifier={user.identifier}")
         existing_user: Optional["PersistedUser"] = await self.get_user(user.identifier)
         user_dict: Dict[str, Any] = {
             "identifier": str(user.identifier),
             "metadata": json.dumps(user.metadata) or {},
         }
         if not existing_user:  # create the user
-            logger.info("SQLAlchemy: create_user, creating the user")
+            if self.show_logger: logger.info("SQLAlchemy: create_user, creating the user")
             user_dict["id"] = str(uuid.uuid4())
             user_dict["createdAt"] = await self.get_current_timestamp()
             query = """INSERT INTO users ("id", "identifier", "createdAt", "metadata") VALUES (:id, :identifier, :createdAt, :metadata)"""
             await self.execute_sql(query=query, parameters=user_dict)
         else:  # update the user
-            logger.info("SQLAlchemy: update user metadata")
+            if self.show_logger: logger.info("SQLAlchemy: update user metadata")
             query = """UPDATE users SET "metadata" = :metadata WHERE "identifier" = :identifier"""
             await self.execute_sql(
                 query=query, parameters=user_dict
@@ -134,19 +136,18 @@ class SQLAlchemyDataLayer(BaseDataLayer):
 
     ###### Threads ######
     async def get_thread_author(self, thread_id: str) -> str:
-        logger.info(f"SQLAlchemy: get_thread_author, thread_id={thread_id}")
+        if self.show_logger: logger.info(f"SQLAlchemy: get_thread_author, thread_id={thread_id}")
         query = """SELECT "userIdentifier" FROM threads WHERE "id" = :id"""
         parameters = {"id": thread_id}
         result = await self.execute_sql(query=query, parameters=parameters)
         if isinstance(result, list) and result[0]:
             author_identifier = result[0].get("userIdentifier")
             if author_identifier is not None:
-                print(f"Author found: {author_identifier}")
                 return author_identifier
         raise ValueError(f"Author not found for thread_id {thread_id}")
 
     async def get_thread(self, thread_id: str) -> Optional[ThreadDict]:
-        logger.info(f"SQLAlchemy: get_thread, thread_id={thread_id}")
+        if self.show_logger: logger.info(f"SQLAlchemy: get_thread, thread_id={thread_id}")
         user_threads: Optional[List[ThreadDict]] = await self.get_all_user_threads(
             thread_id=thread_id
         )
@@ -163,19 +164,21 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         metadata: Optional[Dict] = None,
         tags: Optional[List[str]] = None,
     ):
-        logger.info(f"SQLAlchemy: update_thread, thread_id={thread_id}")
+        if self.show_logger: logger.info(f"SQLAlchemy: update_thread, thread_id={thread_id}")
         if context.session.user is not None:
             user_identifier = context.session.user.identifier
         else:
             raise ValueError("User not found in session context")
         data = {
             "id": thread_id,
-            "createdAt": await self.get_current_timestamp()
-            if metadata is None
-            else None,
-            "name": name
-            if name is not None
-            else (metadata.get("name") if metadata and "name" in metadata else None),
+            "createdAt": (
+                await self.get_current_timestamp() if metadata is None else None
+            ),
+            "name": (
+                name
+                if name is not None
+                else (metadata.get("name") if metadata and "name" in metadata else None)
+            ),
             "userId": user_id,
             "userIdentifier": user_identifier,
             "tags": tags,
@@ -198,7 +201,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         await self.execute_sql(query=query, parameters=parameters)
 
     async def delete_thread(self, thread_id: str):
-        logger.info(f"SQLAlchemy: delete_thread, thread_id={thread_id}")
+        if self.show_logger: logger.info(f"SQLAlchemy: delete_thread, thread_id={thread_id}")
         # Delete feedbacks/elements/steps/thread
         feedbacks_query = """DELETE FROM feedbacks WHERE "forId" IN (SELECT "id" FROM steps WHERE "threadId" = :id)"""
         elements_query = """DELETE FROM elements WHERE "threadId" = :id"""
@@ -213,7 +216,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
     async def list_threads(
         self, pagination: Pagination, filters: ThreadFilter
     ) -> PaginatedResponse:
-        logger.info(
+        if self.show_logger: logger.info(
             f"SQLAlchemy: list_threads, pagination={pagination}, filters={filters}"
         )
         if not filters.userId:
@@ -273,7 +276,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
     ###### Steps ######
     @queue_until_user_message()
     async def create_step(self, step_dict: "StepDict"):
-        logger.info(f"SQLAlchemy: create_step, step_id={step_dict.get('id')}")
+        if self.show_logger: logger.info(f"SQLAlchemy: create_step, step_id={step_dict.get('id')}")
         if not getattr(context.session.user, "id", None):
             raise ValueError("No authenticated user in context")
         step_dict["showInput"] = (
@@ -303,12 +306,12 @@ class SQLAlchemyDataLayer(BaseDataLayer):
 
     @queue_until_user_message()
     async def update_step(self, step_dict: "StepDict"):
-        logger.info(f"SQLAlchemy: update_step, step_id={step_dict.get('id')}")
+        if self.show_logger: logger.info(f"SQLAlchemy: update_step, step_id={step_dict.get('id')}")
         await self.create_step(step_dict)
 
     @queue_until_user_message()
     async def delete_step(self, step_id: str):
-        logger.info(f"SQLAlchemy: delete_step, step_id={step_id}")
+        if self.show_logger: logger.info(f"SQLAlchemy: delete_step, step_id={step_id}")
         # Delete feedbacks/elements/steps
         feedbacks_query = """DELETE FROM feedbacks WHERE "forId" = :id"""
         elements_query = """DELETE FROM elements WHERE "forId" = :id"""
@@ -320,7 +323,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
 
     ###### Feedback ######
     async def upsert_feedback(self, feedback: Feedback) -> str:
-        logger.info(f"SQLAlchemy: upsert_feedback, feedback_id={feedback.id}")
+        if self.show_logger: logger.info(f"SQLAlchemy: upsert_feedback, feedback_id={feedback.id}")
         feedback.id = feedback.id or str(uuid.uuid4())
         feedback_dict = asdict(feedback)
         parameters = {
@@ -342,7 +345,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         return feedback.id
 
     async def delete_feedback(self, feedback_id: str) -> bool:
-        logger.info(f"SQLAlchemy: delete_feedback, feedback_id={feedback_id}")
+        if self.show_logger: logger.info(f"SQLAlchemy: delete_feedback, feedback_id={feedback_id}")
         query = """DELETE FROM feedbacks WHERE "id" = :feedback_id"""
         parameters = {"feedback_id": feedback_id}
         await self.execute_sql(query=query, parameters=parameters)
@@ -351,7 +354,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
     ###### Elements ######
     @queue_until_user_message()
     async def create_element(self, element: "Element"):
-        logger.info(f"SQLAlchemy: create_element, element_id = {element.id}")
+        if self.show_logger: logger.info(f"SQLAlchemy: create_element, element_id = {element.id}")
         if not getattr(context.session.user, "id", None):
             raise ValueError("No authenticated user in context")
         if isinstance(element, Avatar):  # Skip creating elements of type avatar
@@ -414,7 +417,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
 
     @queue_until_user_message()
     async def delete_element(self, element_id: str):
-        logger.info(f"SQLAlchemy: delete_element, element_id={element_id}")
+        if self.show_logger: logger.info(f"SQLAlchemy: delete_element, element_id={element_id}")
         query = """DELETE FROM elements WHERE "id" = :id"""
         parameters = {"id": element_id}
         await self.execute_sql(query=query, parameters=parameters)
@@ -426,7 +429,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
         self, user_id: Optional[str] = None, thread_id: Optional[str] = None
     ) -> Optional[List[ThreadDict]]:
         """Fetch all user threads up to self.user_thread_limit, or one thread by id if thread_id is provided."""
-        logger.info(f"SQLAlchemy: get_all_user_threads")
+        if self.show_logger: logger.info(f"SQLAlchemy: get_all_user_threads")
         user_threads_query = """
             SELECT
                 "id" AS thread_id,
@@ -552,13 +555,17 @@ class SQLAlchemyDataLayer(BaseDataLayer):
                         streaming=step_feedback.get("step_streaming", False),
                         waitForAnswer=step_feedback.get("step_waitforanswer"),
                         isError=step_feedback.get("step_iserror"),
-                        metadata=step_feedback["step_metadata"]
-                        if step_feedback.get("step_metadata") is not None
-                        else {},
+                        metadata=(
+                            step_feedback["step_metadata"]
+                            if step_feedback.get("step_metadata") is not None
+                            else {}
+                        ),
                         tags=step_feedback.get("step_tags"),
-                        input=step_feedback.get("step_input", "")
-                        if step_feedback["step_showinput"]
-                        else "",
+                        input=(
+                            step_feedback.get("step_input", "")
+                            if step_feedback["step_showinput"] == "true" 
+                            else None
+                        ),
                         output=step_feedback.get("step_output", ""),
                         createdAt=step_feedback.get("step_createdat"),
                         start=step_feedback.get("step_start"),
@@ -587,6 +594,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
                         display=element["element_display"],
                         size=element.get("element_size"),
                         language=element.get("element_language"),
+                        autoPlay=element.get("element_autoPlay"),
                         page=element.get("element_page"),
                         forId=element.get("element_forid"),
                         mime=element.get("element_mime"),

chainlit/discord/__init__.py

@@ -0,0 +1,6 @@
+try:
+    import discord
+except ModuleNotFoundError:
+    raise ValueError(
+        "The discord package is required to integrate Chainlit with a Slack app. Run `pip install discord --upgrade`"
+    )

chainlit/discord/app.py

@@ -0,0 +1,304 @@
+import asyncio
+import mimetypes
+import re
+import uuid
+from io import BytesIO
+from typing import Dict, List, Optional, Union, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from discord.abc import MessageableChannel
+
+import discord
+
+import filetype
+import httpx
+from chainlit.config import config
+from chainlit.context import ChainlitContext, HTTPSession, context_var
+from chainlit.data import get_data_layer
+from chainlit.element import Element, ElementDict
+from chainlit.emitter import BaseChainlitEmitter
+from chainlit.logger import logger
+from chainlit.message import Message, StepDict
+from chainlit.types import Feedback
+from chainlit.user import PersistedUser, User
+from chainlit.user_session import user_session
+from discord.ui import Button, View
+
+
+class FeedbackView(View):
+    def __init__(self, step_id: str):
+        super().__init__(timeout=None)
+        self.step_id = step_id
+
+    @discord.ui.button(label="👎")
+    async def thumbs_down(self, interaction: discord.Interaction, button: Button):
+        if data_layer := get_data_layer():
+            await data_layer.upsert_feedback(Feedback(forId=self.step_id, value=0))
+        if interaction.message:
+            await interaction.message.edit(view=None)
+            await interaction.message.add_reaction("👎")
+
+    @discord.ui.button(label="👍")
+    async def thumbs_up(self, interaction: discord.Interaction, button: Button):
+        if data_layer := get_data_layer():
+            await data_layer.upsert_feedback(Feedback(forId=self.step_id, value=1))
+        if interaction.message:
+            await interaction.message.edit(view=None)
+            await interaction.message.add_reaction("👍")
+
+
+class DiscordEmitter(BaseChainlitEmitter):
+    def __init__(
+        self, session: HTTPSession, channel: "MessageableChannel", enabled=False
+    ):
+        super().__init__(session)
+        self.channel = channel
+        self.enabled = enabled
+
+    async def send_element(self, element_dict: ElementDict):
+        if not self.enabled or element_dict.get("display") != "inline":
+            return
+
+        persisted_file = self.session.files.get(element_dict.get("chainlitKey") or "")
+        file: Optional[Union[BytesIO, str]] = None
+        mime: Optional[str] = None
+
+        if persisted_file:
+            file = str(persisted_file["path"])
+            mime = element_dict.get("mime")
+        elif file_url := element_dict.get("url"):
+            async with httpx.AsyncClient() as client:
+                response = await client.get(file_url)
+                if response.status_code == 200:
+                    file = BytesIO(response.content)
+                    mime = filetype.guess_mime(file)
+
+        if not file:
+            return
+
+        element_name: str = element_dict.get("name", "Untitled")
+
+        if mime:
+            file_extension = mimetypes.guess_extension(mime)
+            if file_extension:
+                element_name += file_extension
+
+        file_obj = discord.File(file, filename=element_name)
+        await self.channel.send(file=file_obj)
+
+    async def send_step(self, step_dict: StepDict):
+        if not self.enabled:
+            return
+
+        is_chain_of_thought = bool(step_dict.get("parentId"))
+        is_empty_output = not step_dict.get("output")
+
+        if is_chain_of_thought or is_empty_output:
+            return
+        else:
+            enable_feedback = not step_dict.get("disableFeedback") and get_data_layer()
+            message = await self.channel.send(step_dict["output"])
+
+            if enable_feedback:
+                view = FeedbackView(step_dict.get("id", ""))
+                await message.edit(view=view)
+
+    async def update_step(self, step_dict: StepDict):
+        if not self.enabled:
+            return
+
+        await self.send_step(step_dict)
+
+
+intents = discord.Intents.default()
+intents.message_content = True
+
+client = discord.Client(intents=intents)
+
+
+def init_discord_context(
+    session: HTTPSession,
+    channel: "MessageableChannel",
+    message: discord.Message,
+) -> ChainlitContext:
+    emitter = DiscordEmitter(session=session, channel=channel)
+    context = ChainlitContext(session=session, emitter=emitter)
+    context_var.set(context)
+    user_session.set("discord_message", message)
+    user_session.set("discord_channel", channel)
+    return context
+
+
+users_by_discord_id: Dict[int, Union[User, PersistedUser]] = {}
+
+USER_PREFIX = "discord_"
+
+
+async def get_user(discord_user: Union[discord.User, discord.Member]):
+    metadata = {
+        "name": discord_user.name,
+        "id": discord_user.id,
+    }
+    user = User(identifier=USER_PREFIX + str(discord_user.name), metadata=metadata)
+
+    users_by_discord_id[discord_user.id] = user
+
+    if data_layer := get_data_layer():
+        persisted_user = await data_layer.create_user(user)
+        if persisted_user:
+            users_by_discord_id[discord_user.id] = persisted_user
+
+    return users_by_discord_id[discord_user.id]
+
+
+async def download_discord_file(url: str):
+    async with httpx.AsyncClient() as client:
+        response = await client.get(url)
+        if response.status_code == 200:
+            return response.content
+        else:
+            return None
+
+
+async def download_discord_files(
+    session: HTTPSession, attachments: List[discord.Attachment]
+):
+    download_coros = [
+        download_discord_file(attachment.url) for attachment in attachments
+    ]
+    file_bytes_list = await asyncio.gather(*download_coros)
+    file_refs = []
+    for idx, file_bytes in enumerate(file_bytes_list):
+        if file_bytes:
+            name = attachments[idx].filename
+            mime_type = attachments[idx].content_type or "application/octet-stream"
+            file_ref = await session.persist_file(
+                name=name, mime=mime_type, content=file_bytes
+            )
+            file_refs.append(file_ref)
+
+    files_dicts = [
+        session.files[file["id"]] for file in file_refs if file["id"] in session.files
+    ]
+
+    file_elements = [Element.from_dict(file_dict) for file_dict in files_dicts]
+
+    return file_elements
+
+
+def clean_content(message: discord.Message):
+    if not client.user:
+        return message.content
+
+    # Regex to find mentions of the bot
+    bot_mention = f"<@!?{client.user.id}>"
+    # Replace the bot's mention with nothing
+    return re.sub(bot_mention, "", message.content).strip()
+
+
+async def process_discord_message(
+    message: discord.Message,
+    thread_name: str,
+    channel: "MessageableChannel",
+    bind_thread_to_user=False,
+):
+    user = await get_user(message.author)
+
+    thread_id = str(uuid.uuid5(uuid.NAMESPACE_DNS, str(channel.id)))
+
+    text = clean_content(message)
+    discord_files = message.attachments
+
+    session_id = str(uuid.uuid4())
+    session = HTTPSession(
+        id=session_id,
+        thread_id=thread_id,
+        user=user,
+        client_type="discord",
+    )
+
+    ctx = init_discord_context(
+        session=session,
+        channel=channel,
+        message=message,
+    )
+
+    file_elements = await download_discord_files(session, discord_files)
+
+    msg = Message(
+        content=text,
+        elements=file_elements,
+        type="user_message",
+        author=user.metadata.get("name"),
+    )
+
+    await msg.send()
+
+    ctx.emitter.enabled = True
+
+    if on_chat_start := config.code.on_chat_start:
+        await on_chat_start()
+
+    if on_message := config.code.on_message:
+        await on_message(msg)
+
+    if on_chat_end := config.code.on_chat_end:
+        await on_chat_end()
+
+    if data_layer := get_data_layer():
+        user_id = None
+        if isinstance(user, PersistedUser):
+            user_id = user.id if bind_thread_to_user else None
+
+        await data_layer.update_thread(
+            thread_id=thread_id,
+            name=thread_name,
+            metadata=ctx.session.to_persistable(),
+            user_id=user_id,
+        )
+
+    ctx.session.delete()
+
+
+@client.event
+async def on_ready():
+    logger.info(f"Logged in as {client.user}")
+
+
+@client.event
+async def on_message(message: discord.Message):
+    if not client.user or message.author == client.user:
+        return
+    
+    is_dm = isinstance(message.channel, discord.DMChannel)
+    if not client.user.mentioned_in(message) and not is_dm:
+        return
+
+    thread_name: str = ""
+    bind_thread_to_user = False
+    channel = message.channel
+
+    if isinstance(message.channel, discord.Thread):
+        thread_name = f"{message.channel.name}"
+    elif isinstance(message.channel, discord.ForumChannel):
+        thread_name = f"{message.channel.name}"
+    elif isinstance(message.channel, discord.DMChannel):
+        thread_name = f"{message.author} Discord DM"
+        bind_thread_to_user = True
+    elif isinstance(message.channel, discord.GroupChannel):
+        thread_name = f"{message.channel.name}"
+    elif isinstance(message.channel, discord.TextChannel):
+        channel = await message.channel.create_thread(
+            name=clean_content(message), message=message
+        )
+        thread_name = f"{channel.name}"
+    else:
+        logger.warning(f"Unsupported channel type: {message.channel.type}")
+        return
+
+    await process_discord_message(
+        message=message,
+        thread_name=thread_name,
+        channel=channel,
+        bind_thread_to_user=bind_thread_to_user,
+    )

chainlit/element.py

@@ -5,6 +5,7 @@ from io import BytesIO
 from typing import Any, ClassVar, List, Literal, Optional, TypedDict, TypeVar, Union
 
 import filetype
+import mimetypes
 from chainlit.context import context
 from chainlit.data import get_data_layer
 from chainlit.logger import logger
@@ -38,6 +39,7 @@ class ElementDict(TypedDict):
     size: Optional[ElementSize]
     language: Optional[str]
     page: Optional[int]
+    autoPlay: Optional[bool]
     forId: Optional[str]
     mime: Optional[str]
 
@@ -61,7 +63,7 @@ class Element:
     # The byte content of the element.
     content: Optional[Union[bytes, str]] = None
     # Controls how the image element should be displayed in the UI. Choices are “side” (default), “inline”, or “page”.
-    display: ElementDisplay = Field(default="side")
+    display: ElementDisplay = Field(default="inline")
     # Controls element size
     size: Optional[ElementSize] = None
     # The ID of the message this element is associated with.
@@ -93,6 +95,7 @@ class Element:
                 "objectKey": getattr(self, "object_key", None),
                 "size": getattr(self, "size", None),
                 "page": getattr(self, "page", None),
+                "autoPlay": getattr(self, "auto_play", None),
                 "language": getattr(self, "language", None),
                 "forId": getattr(self, "for_id", None),
                 "mime": getattr(self, "mime", None),
@@ -163,14 +166,16 @@ class Element:
                 if self.type in mime_types
                 else filetype.guess_mime(self.path or self.content)
             )
-
+            if not self.mime and self.url:
+                self.mime = mimetypes.guess_type(self.url)[0]
+            
         await self._create()
 
         if not self.url and not self.chainlit_key:
             raise ValueError("Must provide url or chainlit key to send element")
 
         trace_event(f"send {self.__class__.__name__}")
-        await context.emitter.emit("element", self.to_dict())
+        await context.emitter.send_element(self.to_dict())
 
 
 ElementBased = TypeVar("ElementBased", bound=Element)
@@ -306,6 +311,7 @@ class TaskList(Element):
 @dataclass
 class Audio(Element):
     type: ClassVar[ElementType] = "audio"
+    auto_play: bool = False
 
 
 @dataclass

chainlit/emitter.py

@@ -4,10 +4,10 @@ from typing import Any, Dict, List, Literal, Optional, Union, cast
 
 from chainlit.config import config
 from chainlit.data import get_data_layer
-from chainlit.element import Element, File
+from chainlit.element import Element, ElementDict, File
 from chainlit.logger import logger
 from chainlit.message import Message
-from chainlit.session import BaseSession, WebsocketSession
+from chainlit.session import BaseSession, HTTPSession, WebsocketSession
 from chainlit.step import StepDict
 from chainlit.types import (
     AskActionResponse,
@@ -29,6 +29,7 @@ class BaseChainlitEmitter:
     """
 
     session: BaseSession
+    enabled: bool = True
 
     def __init__(self, session: BaseSession) -> None:
         """Initialize with the user session."""
@@ -46,6 +47,10 @@ class BaseChainlitEmitter:
         """Stub method to resume a thread."""
         pass
 
+    async def send_element(self, element_dict: ElementDict):
+        """Stub method to send an element to the UI."""
+        pass
+
     async def send_step(self, step_dict: StepDict):
         """Stub method to send a message to the UI."""
         pass
@@ -151,6 +156,10 @@ class ChainlitEmitter(BaseChainlitEmitter):
         """Send a thread to the UI to resume it"""
         return self.emit("resume_thread", thread_dict)
 
+    async def send_element(self, element_dict: ElementDict):
+        """Stub method to send an element to the UI."""
+        await self.emit("element", element_dict)
+
     def send_step(self, step_dict: StepDict):
         """Send a message to the UI."""
         return self.emit("new_message", step_dict)