feat: ai app streaming and loading states

Author: srtaalej

.slack/.gitignore

@@ -0,0 +1,2 @@
+apps.dev.json
+cache/

.slack/config.json

@@ -0,0 +1,6 @@
+{
+  "manifest": {
+    "source": "remote"
+  },
+  "project_id": "22e2b5e7-ef8f-4fbf-8026-a62ae0623037"
+}

.slack/hooks.json

@@ -0,0 +1,5 @@
+{
+  "hooks": {
+    "get-hooks": "python3 -m slack_cli_hooks.hooks.get_hooks"
+  }
+}

listeners/assistant/assistant.py

@@ -1,9 +1,8 @@
 import logging
 from typing import List, Dict
-from slack_bolt import Assistant, BoltContext, Say, SetSuggestedPrompts, SetStatus
+from slack_bolt import Assistant, BoltContext, Say, SetSuggestedPrompts
 from slack_bolt.context.get_thread_context import GetThreadContext
 from slack_sdk import WebClient
-from slack_sdk.errors import SlackApiError
 
 from ..llm_caller import call_llm
 
@@ -57,39 +56,20 @@ def respond_in_assistant_thread(
     payload: dict,
     logger: logging.Logger,
     context: BoltContext,
-    set_status: SetStatus,
-    get_thread_context: GetThreadContext,
     client: WebClient,
     say: Say,
 ):
     try:
-        user_message = payload["text"]
-        set_status("is typing...")
-
-        if user_message == "Can you generate a brief summary of the referred channel?":
-            # the logic here requires the additional bot scopes:
-            # channels:join, channels:history, groups:history
-            thread_context = get_thread_context()
-            referred_channel_id = thread_context.get("channel_id")
-            try:
-                channel_history = client.conversations_history(channel=referred_channel_id, limit=50)
-            except SlackApiError as e:
-                if e.response["error"] == "not_in_channel":
-                    # If this app's bot user is not in the public channel,
-                    # we'll try joining the channel and then calling the same API again
-                    client.conversations_join(channel=referred_channel_id)
-                    channel_history = client.conversations_history(channel=referred_channel_id, limit=50)
-                else:
-                    raise e
+        channel_id = payload["channel"]
+        thread_ts = payload["thread_ts"]
 
-            prompt = f"Can you generate a brief summary of these messages in a Slack channel <#{referred_channel_id}>?\n\n"
-            for message in reversed(channel_history.get("messages")):
-                if message.get("user") is not None:
-                    prompt += f"\n<@{message['user']}> says: {message['text']}\n"
-            messages_in_thread = [{"role": "user", "content": prompt}]
-            returned_message = call_llm(messages_in_thread)
-            say(returned_message)
-            return
+        loading_messages = [
+            "Teaching the hamsters to type faster…",
+            "Untangling the internet cables…",
+            "Consulting the office goldfish…",
+            "Polishing up the response just for you…",
+            "Convincing the AI to stop overthinking…",
+        ]
 
         replies = client.conversations_replies(
             channel=context.channel_id,
@@ -101,8 +81,28 @@ def respond_in_assistant_thread(
         for message in replies["messages"]:
             role = "user" if message.get("bot_id") is None else "assistant"
             messages_in_thread.append({"role": role, "content": message["text"]})
+
         returned_message = call_llm(messages_in_thread)
-        say(returned_message)
+        client.assistant_threads_setStatus(
+            channel_id=channel_id, thread_ts=thread_ts, status="Bolt is typing", loading_messages=loading_messages
+        )
+        stream_response = client.chat_startStream(
+            channel=channel_id,
+            thread_ts=thread_ts,
+        )
+        stream_ts = stream_response["ts"]
+        # use of this for loop is specific to openai response method
+        for event in returned_message:
+            print(f"\n{event.type}")
+            if event.type == "response.output_text.delta":
+                client.chat_appendStream(channel=channel_id, ts=stream_ts, markdown_text=f"{event.delta}")
+            else:
+                continue
+
+        client.chat_stopStream(
+            channel=channel_id,
+            ts=stream_ts,
+        )
 
     except Exception as e:
         logger.exception(f"Failed to handle a user message event: {e}")

listeners/llm_caller.py

@@ -1,8 +1,10 @@
 import os
-import re
 from typing import List, Dict
 
 import openai
+from openai import Stream
+from openai.types.responses import ResponseStreamEvent
+
 
 DEFAULT_SYSTEM_CONTENT = """
 You're an assistant in a Slack workspace.
@@ -16,44 +18,9 @@
 def call_llm(
     messages_in_thread: List[Dict[str, str]],
     system_content: str = DEFAULT_SYSTEM_CONTENT,
-) -> str:
+) -> Stream[ResponseStreamEvent]:
     openai_client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
     messages = [{"role": "system", "content": system_content}]
     messages.extend(messages_in_thread)
-    response = openai_client.chat.completions.create(
-        model="gpt-4o-mini",
-        n=1,
-        messages=messages,
-        max_tokens=16384,
-    )
-    return markdown_to_slack(response.choices[0].message.content)
-
-
-# Conversion from OpenAI markdown to Slack mrkdwn
-# See also: https://api.slack.com/reference/surfaces/formatting#basics
-def markdown_to_slack(content: str) -> str:
-    # Split the input string into parts based on code blocks and inline code
-    parts = re.split(r"(?s)(```.+?```|`[^`\n]+?`)", content)
-
-    # Apply the bold, italic, and strikethrough formatting to text not within code
-    result = ""
-    for part in parts:
-        if part.startswith("```") or part.startswith("`"):
-            result += part
-        else:
-            for o, n in [
-                (
-                    r"\*\*\*(?!\s)([^\*\n]+?)(?<!\s)\*\*\*",
-                    r"_*\1*_",
-                ),  # ***bold italic*** to *_bold italic_*
-                (
-                    r"(?<![\*_])\*(?!\s)([^\*\n]+?)(?<!\s)\*(?![\*_])",
-                    r"_\1_",
-                ),  # *italic* to _italic_
-                (r"\*\*(?!\s)([^\*\n]+?)(?<!\s)\*\*", r"*\1*"),  # **bold** to *bold*
-                (r"__(?!\s)([^_\n]+?)(?<!\s)__", r"*\1*"),  # __bold__ to *bold*
-                (r"~~(?!\s)([^~\n]+?)(?<!\s)~~", r"~\1~"),  # ~~strike~~ to ~strike~
-            ]:
-                part = re.sub(o, n, part)
-            result += part
-    return result
+    response = openai_client.responses.create(model="gpt-4o-mini", input=messages, stream=True)
+    return response

requirements.txt

@@ -1,5 +1,6 @@
 slack-bolt>=1.21,<2
-slack-sdk>=3.33.1,<4
+slack-cli-hooks<1.0.0
+slack_sdk==3.36.0.dev0
 # If you use a different LLM vendor, replace this dependency
 openai