chainlit 1.1.305__py3-none-any.whl → 1.1.400__py3-none-any.whl

chainlit/slack/app.py

@@ -2,12 +2,13 @@ import asyncio
 import os
 import re
 import uuid
+from datetime import datetime
 from functools import partial
 from typing import Dict, List, Optional, Union
 
 import httpx
 from chainlit.config import config
-from chainlit.context import ChainlitContext, HTTPSession, context_var
+from chainlit.context import ChainlitContext, HTTPSession, context, context_var
 from chainlit.data import get_data_layer
 from chainlit.element import Element, ElementDict
 from chainlit.emitter import BaseChainlitEmitter
@@ -28,18 +29,16 @@ class SlackEmitter(BaseChainlitEmitter):
         app: AsyncApp,
         channel_id: str,
         say,
-        enabled=False,
         thread_ts: Optional[str] = None,
     ):
         super().__init__(session)
         self.app = app
         self.channel_id = channel_id
         self.say = say
-        self.enabled = enabled
         self.thread_ts = thread_ts
 
     async def send_element(self, element_dict: ElementDict):
-        if not self.enabled or element_dict.get("display") != "inline":
+        if element_dict.get("display") != "inline":
             return
 
         persisted_file = self.session.files.get(element_dict.get("chainlitKey") or "")
@@ -64,21 +63,14 @@ class SlackEmitter(BaseChainlitEmitter):
         )
 
     async def send_step(self, step_dict: StepDict):
-        if not self.enabled:
-            return
-
         step_type = step_dict.get("type")
-        is_message = step_type in [
-            "user_message",
-            "assistant_message",
-        ]
-        is_chain_of_thought = bool(step_dict.get("parentId"))
+        is_assistant_message = step_type == "assistant_message"
         is_empty_output = not step_dict.get("output")
 
-        if is_chain_of_thought or is_empty_output or not is_message:
+        if is_empty_output or not is_assistant_message:
             return
 
-        enable_feedback = not step_dict.get("disableFeedback") and get_data_layer()
+        enable_feedback = get_data_layer()
         blocks: List[Dict] = [
             {
                 "type": "section",
@@ -86,6 +78,8 @@ class SlackEmitter(BaseChainlitEmitter):
             }
         ]
         if enable_feedback:
+            current_run = context.current_run
+            scorable_id = current_run.id if current_run else step_dict.get("id")
             blocks.append(
                 {
                     "type": "actions",
@@ -98,7 +92,7 @@ class SlackEmitter(BaseChainlitEmitter):
                                 "emoji": True,
                                 "text": ":thumbsdown:",
                             },
-                            "value": step_dict.get("id"),
+                            "value": scorable_id,
                         },
                         {
                             "action_id": "thumbup",
@@ -108,7 +102,7 @@ class SlackEmitter(BaseChainlitEmitter):
                                 "emoji": True,
                                 "text": ":thumbsup:",
                             },
-                            "value": step_dict.get("id"),
+                            "value": scorable_id,
                         },
                     ],
                 }
@@ -118,7 +112,9 @@ class SlackEmitter(BaseChainlitEmitter):
         )
 
     async def update_step(self, step_dict: StepDict):
-        if not self.enabled:
+        is_assistant_message = step_dict["type"] == "assistant_message"
+
+        if not is_assistant_message:
             return
 
         await self.send_step(step_dict)
@@ -247,6 +243,7 @@ async def download_slack_files(session: HTTPSession, files, token):
 async def process_slack_message(
     event,
     say,
+    thread_id: str,
     thread_name: Optional[str] = None,
     bind_thread_to_user=False,
     thread_ts: Optional[str] = None,
@@ -254,7 +251,6 @@ async def process_slack_message(
     user = await get_user(event["user"])
 
     channel_id = event["channel"]
-    thread_id = str(uuid.uuid5(uuid.NAMESPACE_DNS, thread_ts or channel_id))
 
     text = event.get("text")
     slack_files = event.get("files", [])
@@ -279,6 +275,9 @@ async def process_slack_message(
         session, slack_files, slack_app.client.token
     )
 
+    if on_chat_start := config.code.on_chat_start:
+        await on_chat_start()
+
     msg = Message(
         content=clean_content(text),
         elements=file_elements,
@@ -288,11 +287,6 @@ async def process_slack_message(
 
     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)
 
@@ -325,14 +319,29 @@ async def handle_app_home_opened(event, say):
 @slack_app.event("app_mention")
 async def handle_app_mentions(event, say):
     thread_ts = event.get("thread_ts", event["ts"])
-    await process_slack_message(event, say, thread_ts=thread_ts)
+    thread_id = str(uuid.uuid5(uuid.NAMESPACE_DNS, thread_ts))
+
+    await process_slack_message(event, say, thread_id=thread_id, thread_ts=thread_ts)
 
 
 @slack_app.event("message")
 async def handle_message(message, say):
-    user = await get_user(message["user"])
-    thread_name = f"{user.identifier} Slack DM"
-    await process_slack_message(message, say, thread_name)
+    thread_id = str(
+        uuid.uuid5(
+            uuid.NAMESPACE_DNS,
+            message["channel"] + datetime.today().strftime("%Y-%m-%d"),
+        )
+    )
+    thread_ts = message.get("thread_ts", message["ts"])
+    thread_id = str(uuid.uuid5(uuid.NAMESPACE_DNS, thread_ts))
+
+    await process_slack_message(
+        event=message,
+        say=say,
+        thread_id=thread_id,
+        bind_thread_to_user=True,
+        thread_ts=thread_ts,
+    )
 
 
 @slack_app.block_action("thumbdown")
@@ -341,8 +350,7 @@ async def thumb_down(ack, context, body):
     step_id = body["actions"][0]["value"]
 
     if data_layer := get_data_layer():
-        thread_id = context_var.get().session.thread_id
-        feedback = Feedback(forId=step_id, threadId=thread_id, value=0)
+        feedback = Feedback(forId=step_id, value=0)
         await data_layer.upsert_feedback(feedback)
 
     text = body["message"]["text"]
@@ -368,8 +376,7 @@ async def thumb_up(ack, context, body):
     step_id = body["actions"][0]["value"]
 
     if data_layer := get_data_layer():
-        thread_id = context_var.get().session.thread_id
-        feedback = Feedback(forId=step_id, threadId=thread_id, value=1)
+        feedback = Feedback(forId=step_id, value=1)
         await data_layer.upsert_feedback(feedback)
 
     text = body["message"]["text"]

chainlit/socket.py

@@ -7,6 +7,7 @@ from urllib.parse import unquote
 
 from chainlit.action import Action
 from chainlit.auth import get_current_user, require_login
+from chainlit.chat_context import chat_context
 from chainlit.config import config
 from chainlit.context import init_ws_context
 from chainlit.data import get_data_layer
@@ -183,6 +184,11 @@ async def connection_successful(sid):
                 {"interaction": "resume", "thread_id": thread.get("id")},
             )
             await config.code.on_chat_resume(thread)
+
+            for step in thread.get("steps", []):
+                if "message" in step["type"]:
+                    chat_context.add(Message.from_dict(step))
+
             await context.emitter.resume_thread(thread)
             return
 
@@ -238,7 +244,7 @@ async def stop(sid):
         trace_event("stop_task")
 
         init_ws_context(session)
-        await Message(content="Task manually stopped.", disable_feedback=True).send()
+        await Message(content="Task manually stopped.").send()
 
         if session.current_task:
             session.current_task.cancel()
@@ -269,6 +275,36 @@ async def process_message(session: WebsocketSession, payload: MessagePayload):
         await context.emitter.task_end()
 
 
+@sio.on("edit_message")
+async def edit_message(sid, payload: MessagePayload):
+    """Handle a message sent by the User."""
+    session = WebsocketSession.require(sid)
+    context = init_ws_context(session)
+
+    messages = chat_context.get()
+
+    orig_message = None
+
+    for message in messages:
+        if orig_message:
+            await message.remove()
+
+        if message.id == payload["message"]["id"]:
+            message.content = payload["message"]["output"]
+            await message.update()
+            orig_message = message
+
+    await context.emitter.task_start()
+
+    if config.code.on_message:
+        try:
+            await config.code.on_message(orig_message)
+        except asyncio.CancelledError:
+            pass
+        finally:
+            await context.emitter.task_end()
+
+
 @sio.on("client_message")
 async def message(sid, payload: MessagePayload):
     """Handle a message sent by the User."""

chainlit/step.py

@@ -7,7 +7,7 @@ from functools import wraps
 from typing import Callable, Dict, List, Optional, TypedDict, Union
 
 from chainlit.config import config
-from chainlit.context import context, local_steps
+from chainlit.context import CL_RUN_NAMES, context, local_steps
 from chainlit.data import get_data_layer
 from chainlit.element import Element
 from chainlit.logger import logger
@@ -18,13 +18,35 @@ from literalai.helper import utc_now
 from literalai.step import StepType, TrueStepType
 
 
+def check_add_step_in_cot(step: "Step"):
+    is_message = step.type in [
+        "user_message",
+        "assistant_message",
+    ]
+    is_cl_run = step.name in CL_RUN_NAMES and step.type == "run"
+    if config.ui.cot == "hidden" and not is_message and not is_cl_run:
+        return False
+    return True
+
+
+def stub_step(step: "Step"):
+    return {
+        "type": step.type,
+        "name": step.name,
+        "id": step.id,
+        "parentId": step.parent_id,
+        "threadId": step.thread_id,
+        "input": "",
+        "output": "",
+    }
+
+
 class StepDict(TypedDict, total=False):
     name: str
     type: StepType
     id: str
     threadId: str
     parentId: Optional[str]
-    disableFeedback: bool
     streaming: bool
     waitForAnswer: Optional[bool]
     isError: Optional[bool]
@@ -48,8 +70,8 @@ def step(
     name: Optional[str] = "",
     type: TrueStepType = "undefined",
     id: Optional[str] = None,
+    parent_id: Optional[str] = None,
     tags: Optional[List[str]] = None,
-    disable_feedback: bool = True,
     language: Optional[str] = None,
     show_input: Union[bool, str] = "json",
 ):
@@ -70,7 +92,7 @@ def step(
                     type=type,
                     name=name,
                     id=id,
-                    disable_feedback=disable_feedback,
+                    parent_id=parent_id,
                     tags=tags,
                     language=language,
                     show_input=show_input,
@@ -97,7 +119,7 @@ def step(
                     type=type,
                     name=name,
                     id=id,
-                    disable_feedback=disable_feedback,
+                    parent_id=parent_id,
                     tags=tags,
                     language=language,
                     show_input=show_input,
@@ -130,7 +152,6 @@ class Step:
     type: TrueStepType
     id: str
     parent_id: Optional[str]
-    disable_feedback: bool
 
     streaming: bool
     persisted: bool
@@ -158,7 +179,6 @@ class Step:
         elements: Optional[List[Element]] = None,
         metadata: Optional[Dict] = None,
         tags: Optional[List[str]] = None,
-        disable_feedback: bool = True,
         language: Optional[str] = None,
         show_input: Union[bool, str] = "json",
     ):
@@ -170,7 +190,6 @@ class Step:
         self.name = name or ""
         self.type = type
         self.id = id or str(uuid.uuid4())
-        self.disable_feedback = disable_feedback
         self.metadata = metadata or {}
         self.tags = tags
         self.is_error = False
@@ -256,7 +275,6 @@ class Step:
             "id": self.id,
             "threadId": self.thread_id,
             "parentId": self.parent_id,
-            "disableFeedback": self.disable_feedback,
             "streaming": self.streaming,
             "metadata": self.metadata,
             "tags": self.tags,
@@ -295,13 +313,10 @@ class Step:
         tasks = [el.send(for_id=self.id) for el in self.elements]
         await asyncio.gather(*tasks)
 
-        if config.ui.hide_cot and self.type not in [
-            "user_message",
-            "assistant_message",
-        ]:
-            return True
-
-        await context.emitter.update_step(step_dict)
+        if not check_add_step_in_cot(self):
+            await context.emitter.update_step(stub_step(self))
+        else:
+            await context.emitter.update_step(step_dict)
 
         return True
 
@@ -352,13 +367,10 @@ class Step:
         tasks = [el.send(for_id=self.id) for el in self.elements]
         await asyncio.gather(*tasks)
 
-        if config.ui.hide_cot and self.type not in [
-            "user_message",
-            "assistant_message",
-        ]:
-            return self
-
-        await context.emitter.send_step(step_dict)
+        if not check_add_step_in_cot(self):
+            await context.emitter.send_step(stub_step(self))
+        else:
+            await context.emitter.send_step(step_dict)
 
         return self
 
@@ -380,10 +392,8 @@ class Step:
 
         assert self.id
 
-        if config.ui.hide_cot and self.type not in [
-            "user_message",
-            "assistant_message",
-        ]:
+        if not check_add_step_in_cot(self):
+            await context.emitter.send_step(stub_step(self))
             return
 
         if not self.streaming:
@@ -404,7 +414,6 @@ class Step:
             id=self.id,
             parent_id=self.parent_id,
             thread_id=self.thread_id,
-            disable_feedback=self.disable_feedback,
         )
 
     # Handle Context Manager Protocol
@@ -416,8 +425,6 @@ class Step:
         if not self.parent_id:
             if parent_step:
                 self.parent_id = parent_step.id
-            elif context.session.root_message:
-                self.parent_id = context.session.root_message.id
         context.active_steps.append(self)
         local_steps.set(previous_steps + [self])
         await self.send()
@@ -449,8 +456,6 @@ class Step:
         if not self.parent_id:
             if parent_step:
                 self.parent_id = parent_step.id
-            elif context.session.root_message:
-                self.parent_id = context.session.root_message.id
         context.active_steps.append(self)
         local_steps.set(previous_steps + [self])
 

chainlit/teams/app.py

@@ -3,6 +3,7 @@ import base64
 import mimetypes
 import os
 import uuid
+from datetime import datetime
 from typing import TYPE_CHECKING, Dict, List, Literal, Optional, Union
 
 import filetype
@@ -28,7 +29,7 @@ from botbuilder.schema import (
     HeroCard,
 )
 from chainlit.config import config
-from chainlit.context import ChainlitContext, HTTPSession, context_var
+from chainlit.context import ChainlitContext, HTTPSession, context, context_var
 from chainlit.data import get_data_layer
 from chainlit.element import Element, ElementDict
 from chainlit.emitter import BaseChainlitEmitter
@@ -41,13 +42,12 @@ from chainlit.user_session import user_session
 
 
 class TeamsEmitter(BaseChainlitEmitter):
-    def __init__(self, session: HTTPSession, turn_context: TurnContext, enabled=False):
+    def __init__(self, session: HTTPSession, turn_context: TurnContext):
         super().__init__(session)
         self.turn_context = turn_context
-        self.enabled = enabled
 
     async def send_element(self, element_dict: ElementDict):
-        if not self.enabled or element_dict.get("display") != "inline":
+        if element_dict.get("display") != "inline":
             return
 
         persisted_file = self.session.files.get(element_dict.get("chainlitKey") or "")
@@ -81,7 +81,7 @@ class TeamsEmitter(BaseChainlitEmitter):
         await self.turn_context.send_activity(Activity(attachments=[attachment]))
 
     async def send_step(self, step_dict: StepDict):
-        if not self.enabled:
+        if not step_dict["type"] == "assistant_message":
             return
 
         step_type = step_dict.get("type")
@@ -89,26 +89,27 @@ class TeamsEmitter(BaseChainlitEmitter):
             "user_message",
             "assistant_message",
         ]
-        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 or not is_message:
+        if is_empty_output or not is_message:
             return
         else:
             reply = MessageFactory.text(step_dict["output"])
-            enable_feedback = not step_dict.get("disableFeedback") and get_data_layer()
+            enable_feedback = get_data_layer()
             if enable_feedback:
+                current_run = context.current_run
+                scorable_id = current_run.id if current_run else step_dict["id"]
                 like_button = CardAction(
                     type=ActionTypes.message_back,
                     title="👍",
                     text="like",
-                    value={"feedback": "like", "step_id": step_dict["id"]},
+                    value={"feedback": "like", "step_id": scorable_id},
                 )
                 dislike_button = CardAction(
                     type=ActionTypes.message_back,
                     title="👎",
                     text="dislike",
-                    value={"feedback": "dislike", "step_id": step_dict["id"]},
+                    value={"feedback": "dislike", "step_id": scorable_id},
                 )
                 card = HeroCard(buttons=[like_button, dislike_button])
                 attachment = Attachment(
@@ -119,7 +120,7 @@ class TeamsEmitter(BaseChainlitEmitter):
             await self.turn_context.send_activity(reply)
 
     async def update_step(self, step_dict: StepDict):
-        if not self.enabled:
+        if not step_dict["type"] == "assistant_message":
             return
 
         await self.send_step(step_dict)
@@ -225,7 +226,13 @@ async def process_teams_message(
     user = await get_user(turn_context.activity.from_property)
 
     thread_id = str(
-        uuid.uuid5(uuid.NAMESPACE_DNS, str(turn_context.activity.conversation.id))
+        uuid.uuid5(
+            uuid.NAMESPACE_DNS,
+            str(
+                turn_context.activity.conversation.id
+                + datetime.today().strftime("%Y-%m-%d")
+            ),
+        )
     )
 
     text = clean_content(turn_context.activity)
@@ -247,6 +254,9 @@ async def process_teams_message(
 
     file_elements = await download_teams_files(session, teams_files)
 
+    if on_chat_start := config.code.on_chat_start:
+        await on_chat_start()
+
     msg = Message(
         content=text,
         elements=file_elements,
@@ -256,11 +266,6 @@ async def process_teams_message(
 
     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)
 
@@ -314,7 +319,7 @@ async def handle_message(turn_context: TurnContext):
                 conversation=turn_context.activity.conversation,
             )
             await turn_context.send_activity(typing_activity)
-            thread_name = f"{turn_context.activity.from_property.name} Teams DM"
+            thread_name = f"{turn_context.activity.from_property.name} Teams DM {datetime.today().strftime('%Y-%m-%d')}"
             await process_teams_message(turn_context, thread_name)