Replace slash command handler with event handlers

Author: kris-szlapa

packages/cdk/resources/Apis.ts

@@ -27,15 +27,17 @@ export class Apis extends Construct {
     // Create /slack resource path
     const slackResource = apiGateway.api.root.addResource("slack")
 
-    // Create the '/slack/ask-eps' POST endpoint and integrate it with the SlackBot Lambda
+    // Create the '/slack/events' POST endpoint for Slack Events API
+    // This endpoint will handle @mentions, direct messages, and other Slack events
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const slackAskEpsEndpoint = new LambdaEndpoint(this, "SlackAskEpsEndpoint", {
+    const slackEventsEndpoint = new LambdaEndpoint(this, "SlackEventsEndpoint", {
       parentResource: slackResource,
-      resourceName: "ask-eps",
+      resourceName: "events",
       method: HttpMethod.POST,
       restApiGatewayRole: apiGateway.role,
       lambdaFunction: props.functions.slackBot
     })
+
     this.apis = {
       api: apiGateway
     }

packages/cdk/resources/Functions.ts

@@ -6,7 +6,6 @@ import {Secret} from "aws-cdk-lib/aws-secretsmanager"
 
 // Claude model for RAG responses
 const RAG_MODEL_ID = "anthropic.claude-3-sonnet-20240229-v1:0"
-const SLACK_SLASH_COMMAND = "/ask-eps"
 const BEDROCK_KB_DATA_SOURCE = "eps-assist-kb-ds"
 const LAMBDA_MEMORY_SIZE = "265"
 
@@ -48,7 +47,7 @@ export class Functions extends Construct {
       additionalPolicies: [props.createIndexManagedPolicy]
     })
 
-    // Lambda function to handle Slack bot interactions
+    // Lambda function to handle Slack bot interactions (events and @mentions)
     const slackBotLambda = new LambdaFunction(this, "SlackBotLambda", {
       stackName: props.stackName,
       functionName: `${props.stackName}-SlackBotFunction`,
@@ -59,7 +58,6 @@ export class Functions extends Construct {
       additionalPolicies: [props.slackBotManagedPolicy],
       environmentVariables: {
         "RAG_MODEL_ID": RAG_MODEL_ID,
-        "SLACK_SLASH_COMMAND": SLACK_SLASH_COMMAND,
         "KNOWLEDGEBASE_ID": props.knowledgeBaseId || "placeholder",
         "BEDROCK_KB_DATA_SOURCE": BEDROCK_KB_DATA_SOURCE,
         "LAMBDA_MEMORY_SIZE": LAMBDA_MEMORY_SIZE,

packages/cdk/stacks/EpsAssistMeStack.ts

@@ -130,8 +130,9 @@ export class EpsAssistMeStack extends Stack {
     })
 
     // Output: SlackBot Endpoint
-    new CfnOutput(this, "SlackBotEndpoint", {
-      value: `https://${apis.apis["api"].api.domainName?.domainName}/slack/ask-eps`
+    new CfnOutput(this, "SlackBotEventsEndpoint", {
+      value: `https://${apis.apis["api"].api.domainName?.domainName}/slack/events`,
+      description: "Slack Events API endpoint for @mentions and direct messages"
     })
 
     // Final CDK Nag Suppressions

packages/slackBotFunction/app.py

@@ -29,8 +29,7 @@
     signing_secret=signing_secret,
 )
 
-# Get the expected slack and AWS account params to local vars.
-SLACK_SLASH_COMMAND = os.environ["SLACK_SLASH_COMMAND"]
+# Get the expected AWS account params to local vars.
 KNOWLEDGEBASE_ID = os.environ["KNOWLEDGEBASE_ID"]
 RAG_MODEL_ID = os.environ["RAG_MODEL_ID"]
 AWS_REGION = os.environ["AWS_REGION"]
@@ -49,53 +48,79 @@ def log_request(slack_logger, body, next):
     return next()
 
 
-def respond_to_slack_within_3_seconds(body, ack):
+def respond_to_mention_within_3_seconds(message, say):
     """
-    Slack Bot Slash Command requires an Ack response within 3 seconds or it
+    Slack Bot @mention requires an Ack response within 3 seconds or it
     messages an operation timeout error to the user in the chat thread.
 
     The SlackBolt library provides a Async Ack function then re-invokes this Lambda
-    to LazyLoad the process_command_request command that calls the Bedrock KB ReteriveandGenerate API.
+    to LazyLoad the process_mention_request that calls the Bedrock KB RetrieveAndGenerate API.
 
-    This function is called initially to acknowledge the Slack Slash command within 3 secs.
+    This function is called initially to acknowledge the @mention within 3 secs.
     """
     try:
-        user_query = body["text"]
+        user_query = message["text"]
+        user_id = message["user"]
+        thread_ts = message.get("thread_ts", message["ts"])  # Use thread_ts if in thread, otherwise use message ts
+
         logger.info(
-            f"Acknowledging command: {SLACK_SLASH_COMMAND}",
-            extra={"user_query": user_query},
+            f"Acknowledging @mention from user {user_id}",
+            extra={"user_query": user_query, "thread_ts": thread_ts},
         )
-        ack(f"\n{SLACK_SLASH_COMMAND} - Processing Request: {user_query}")
+
+        # Respond in thread with a processing message
+        say(text="Processing your request...", thread_ts=thread_ts)
 
     except Exception as err:
-        logger.error(f"Error acknowledging command: {err}")
-        ack(f"{SLACK_SLASH_COMMAND} - Sorry an error occurred. Please try again later.")
+        logger.error(f"Error acknowledging @mention: {err}")
+        thread_ts = message.get("thread_ts", message["ts"])
+        say(text="Sorry, an error occurred. Please try again later.", thread_ts=thread_ts)
 
 
-def process_command_request(respond, body):
+def process_mention_request(message, say):
     """
-    Receive the Slack Slash Command user query and proxy the query to Bedrock Knowledge base ReteriveandGenerate API
-    and return the response to Slack to be presented in the users chat thread.
+    Process the @mention user query and proxy the query to Bedrock Knowledge base RetrieveAndGenerate API
+    and return the response to Slack to be presented in the thread.
     """
     try:
-        user_query = body["text"]
+        # Extract the user's query, removing the bot mention
+        raw_text = message["text"]
+        user_id = message["user"]
+        thread_ts = message.get("thread_ts", message["ts"])  # Use thread_ts if in thread, otherwise use message ts
+
+        # Remove bot mention from the text to get clean query
+        # Bot mentions come in format <@U1234567890> or <@U1234567890|botname>
+        import re
+
+        user_query = re.sub(r"<@[UW][A-Z0-9]+(\|[^>]+)?>", "", raw_text).strip()
+
         logger.info(
-            f"Processing command: {SLACK_SLASH_COMMAND}",
-            extra={"user_query": user_query},
+            f"Processing @mention from user {user_id}",
+            extra={"user_query": user_query, "thread_ts": thread_ts},
         )
 
+        if not user_query:
+            say(
+                text="Hi there! Please ask me a question and I'll help you find information from our knowledge base.",
+                thread_ts=thread_ts,
+            )
+            return
+
         kb_response = get_bedrock_knowledgebase_response(user_query)
         response_text = kb_response["output"]["text"]
-        respond(f"\n{SLACK_SLASH_COMMAND} - Response: {response_text}\n")
+
+        # Reply in thread with the response
+        say(text=response_text, thread_ts=thread_ts)
 
     except Exception as err:
-        logger.error(f"Error processing command: {err}")
-        respond(f"{SLACK_SLASH_COMMAND} - Sorry an error occurred. Please try again later.")
+        logger.error(f"Error processing @mention: {err}")
+        thread_ts = message.get("thread_ts", message["ts"])
+        say(text="Sorry, an error occurred while processing your request. Please try again later.", thread_ts=thread_ts)
 
 
 def get_bedrock_knowledgebase_response(user_query):
     """
-    Get and return the Bedrock Knowledge Base ReteriveAndGenerate response.
+    Get and return the Bedrock Knowledge Base RetrieveAndGenerate response.
     Do all init tasks here instead of globally as initial invocation of this lambda
     provides Slack required ack in 3 sec. It doesn't trigger any bedrock functions and is
     time sensitive.
@@ -130,16 +155,28 @@ def get_bedrock_knowledgebase_response(user_query):
     return response
 
 
-# Init the Slack Slash '/' command handler.
-app.command(SLACK_SLASH_COMMAND)(
-    ack=respond_to_slack_within_3_seconds,
-    lazy=[process_command_request],
-)
+# Handle @mentions in channels and DMs
+@app.event("app_mention")
+def handle_app_mention(message, say):
+    """Handle when the bot is @mentioned"""
+    respond_to_mention_within_3_seconds(message, say)
+    # Process the actual request asynchronously
+    process_mention_request(message, say)
+
+
+# Handle direct messages
+@app.event("message")
+def handle_direct_message(message, say):
+    """Handle direct messages to the bot"""
+    # Only respond to direct messages (not channel messages)
+    if message.get("channel_type") == "im":
+        respond_to_mention_within_3_seconds(message, say)
+        process_mention_request(message, say)
 
 
 # Lambda handler method.
 @logger.inject_lambda_context
 def handler(event: dict, context: LambdaContext) -> dict:
-    logger.info(f"Lambda invoked for {SLACK_SLASH_COMMAND}", extra={"event": event})
+    logger.info("Lambda invoked for Slack bot", extra={"event": event})
     slack_handler = SlackRequestHandler(app=app)
     return slack_handler.handle(event, context)