Add WebClient and SlackApiError classes to slackBotFunction

Author: kris-szlapa

packages/slackBotFunction/app.py

@@ -1,151 +1,148 @@
-# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-# SPDX-License-Identifier: MIT-0.
-
-"""
-AWS Lambda hosted Slack ChatBot integration to Amazon Bedrock Knowledge Base.
-Expects Slack Bot Slash Command given by the SLACK_SLASH_COMMAND param and presents
-a user query to the Bedrock Knowledge Base described by the KNOWLEDGEBASE_ID parameter.
-
-The user query is used in a Bedrock KB ReteriveandGenerate API call and the KB
-response is presented to the user in Slack.
-
-Slack integration based on SlackBolt library and examples given at:
-https://github.com/slackapi/bolt-python/blob/main/examples/aws_lambda/lazy_aws_lambda.py
-"""
-
-__version__ = "0.0.1"
-__status__ = "Development"
-__copyright__ = "Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved."
-__author__ = "Dean Colcott <https://www.linkedin.com/in/deancolcott/>"
-
 import os
 import json
 import boto3
 import logging
 from slack_bolt import App
 from slack_bolt.adapter.aws_lambda import SlackRequestHandler
+from slack_sdk import WebClient
+from slack_sdk.errors import SlackApiError
 
 
-# Get params from SSM
+# ================== Helper: AWS SSM Parameter Store ==================
 def get_parameter(parameter_name):
+    """
+    Retrieve a parameter value from AWS SSM Parameter Store.
+    If the value is a JSON string, return the first value.
+    Returns raw string otherwise.
+    Raises on any error.
+    """
     ssm = boto3.client("ssm")
     try:
         response = ssm.get_parameter(Name=parameter_name, WithDecryption=True)
-        # Parse the JSON string from the parameter
         parameter_value = response["Parameter"]["Value"]
 
-        # Remove the JSON structure and extract just the value
         try:
+            # Attempt to parse value as JSON and return the first item.
             json_value = json.loads(parameter_value)
-            # Get the first value from the dictionary
             value = next(iter(json_value.values()))
             return value
         except (json.JSONDecodeError, StopIteration):
-            # If parsing fails or dictionary is empty, return the raw value
+            # Return as string if not valid JSON.
             return parameter_value
 
     except Exception as e:
-        print(f"Error getting parameter {parameter_name}: {str(e)}")
-        raise e
+        logging.error(f"Error getting parameter {parameter_name}: {str(e)}")
+        raise
 
 
-# Get parameter names from environment variables
+# ================== Load Sensitive Configuration ==================
+# Retrieve Slack bot token and signing secret from environment/SSM.
 bot_token_parameter = os.environ["SLACK_BOT_TOKEN_PARAMETER"]
 signing_secret_parameter = os.environ["SLACK_SIGNING_SECRET_PARAMETER"]
 
-# Retrieve the parameters from SSM Parameter Store
 bot_token = get_parameter(bot_token_parameter)
 signing_secret = get_parameter(signing_secret_parameter)
 
-# Initialize Slack app
+
+# ================== Initialize Slack Bolt App ==================
+# Set process_before_response=True to ensure middleware (like logging) runs before Slack gets a response.
 app = App(
     process_before_response=True,
     token=bot_token,
     signing_secret=signing_secret,
 )
 
-# Get the expected slack and AWS account params to local vars.
+
+# ================== Load Other Config from Environment ==================
 SLACK_SLASH_COMMAND = os.environ["SLACK_SLASH_COMMAND"]
 KNOWLEDGEBASE_ID = os.environ["KNOWLEDGEBASE_ID"]
 RAG_MODEL_ID = os.environ["RAG_MODEL_ID"]
 AWS_REGION = os.environ["AWS_REGION"]
 GUARD_RAIL_ID = os.environ["GUARD_RAIL_ID"]
 GUARD_VERSION = os.environ["GUARD_RAIL_VERSION"]
 
-print(f"GR_ID,{GUARD_RAIL_ID}")
-print(f"GR_V, {GUARD_VERSION}")
+logging.info(f"GUARD_RAIL_ID: {GUARD_RAIL_ID}")
+logging.info(f"GUARD_VERSION: {GUARD_VERSION}")
 
 
+# ================== Middleware: Log All Incoming Slack Requests ==================
 @app.middleware
 def log_request(logger, body, next):
     """
-    SlackBolt library logging.
+    Log the entire incoming Slack event body for debugging/audit purposes.
     """
     logger.debug(body)
     return next()
 
 
+# ================== Immediate Ack Handler for Slash Command ==================
 def respond_to_slack_within_3_seconds(body, ack):
     """
-    Slack Bot Slash Command 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.
-
-    This function is called initially to acknowledge the Slack Slash command within 3 secs.
+    Immediately acknowledge the incoming slash command to Slack
+    (must respond in <3 seconds or Slack will show a timeout error).
+    Main processing happens asynchronously in the lazy handler.
     """
     try:
         user_query = body["text"]
         logging.info(
-            f"${SLACK_SLASH_COMMAND} - Acknowledging command: {SLACK_SLASH_COMMAND} - User Query: {user_query}\n"
+            f"Acknowledging slash command {SLACK_SLASH_COMMAND} - User Query: {user_query}"
         )
-        ack(f"\n${SLACK_SLASH_COMMAND} - Processing Request: {user_query}")
-
+        ack(f"\nProcessing Request: {user_query}")
     except Exception as err:
-        print(f"${SLACK_SLASH_COMMAND} - Error: {err}")
-        respond(
-            f"${SLACK_SLASH_COMMAND} - Sorry an error occurred. Please try again later. Error: {err}"
-        )
+        logging.error(f"Ack handler error: {err}")
 
 
+# ================== Main Business Logic for Slash Command ==================
 def process_command_request(respond, body):
     """
-    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.
+    Handle user slash command asynchronously (runs after immediate ack).
+    - Calls Bedrock Knowledge Base with the user's question.
+    - Posts answer as a reply in thread (if present) or as a standalone message.
     """
     try:
-        # Get the user query
         user_query = body["text"]
+        channel_id = body["channel_id"]
+        user_id = body["user_id"]
+        # Use thread_ts for thread replies, or fallback to message_ts
+        thread_ts = body.get("thread_ts") or body.get("message_ts")
+
         logging.info(
-            f"${SLACK_SLASH_COMMAND} - Responding to command: {SLACK_SLASH_COMMAND} - User Query: {user_query}"
+            f"Processing command: {SLACK_SLASH_COMMAND} - User Query: {user_query}"
         )
 
         kb_response = get_bedrock_knowledgebase_response(user_query)
         response_text = kb_response["output"]["text"]
-        respond(f"\n${SLACK_SLASH_COMMAND} - Response: {response_text}\n")
 
+        client = WebClient(token=bot_token)
+
+        # Prepare payload: reply in thread if thread_ts is provided.
+        message_payload = {
+            "channel": channel_id,
+            "text": f"*Question from <@{user_id}>:*\n{user_query}\n\n*Answer:*\n{response_text}"
+        }
+        if thread_ts:
+            message_payload["thread_ts"] = thread_ts
+
+        client.chat_postMessage(**message_payload)
+
+    except SlackApiError as e:
+        logging.error(f"Slack API error posting message: {e.response['error']}")
     except Exception as err:
-        print(f"${SLACK_SLASH_COMMAND} - Error: {err}")
-        respond(
-            f"${SLACK_SLASH_COMMAND} - Sorry an error occurred. Please try again later. Error: {err}"
-        )
+        logging.error(f"Handler error: {err}")
 
 
+# ================== Bedrock Knowledge Base Interaction ==================
 def get_bedrock_knowledgebase_response(user_query):
     """
-    Get and return the Bedrock Knowledge Base ReteriveAndGenerate 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.
+    Query the AWS Bedrock Knowledge Base RetrieveAndGenerate API using the user's question.
+    Loads all Bedrock client config inside the function (avoids Lambda cold start delays in ack handler).
+    Requires the following global variables: AWS_REGION, GUARD_RAIL_ID, GUARD_VERSION, KNOWLEDGEBASE_ID, RAG_MODEL_ID.
     """
-    # Initialise the bedrock-runtime client (in default / running region).
     client = boto3.client(
         service_name="bedrock-agent-runtime",
         region_name=AWS_REGION,
     )
 
-    # Create the RetrieveAndGenerateCommand input with the user query.
     input = {
         "text": user_query,
     }
@@ -171,19 +168,28 @@ def get_bedrock_knowledgebase_response(user_query):
     return response
 
 
-# Init the Slack Slash '/' command handler.
+# ================== Slash Command Registration ==================
+# Register the Slack slash command handler with Bolt:
+# - ack handler responds immediately (must be <3s)
+# - lazy handler processes the command asynchronously
 app.command(SLACK_SLASH_COMMAND)(
     ack=respond_to_slack_within_3_seconds,
     lazy=[process_command_request],
 )
 
-# Init the Slack Bolt logger and log handlers.
+
+# ================== Logging Setup ==================
+# Remove default handlers and configure root logger for DEBUG output.
 SlackRequestHandler.clear_all_log_handlers()
 logging.basicConfig(format="%(asctime)s %(message)s", level=logging.DEBUG)
 
 
-# Lambda handler method.
+# ================== AWS Lambda Entrypoint ==================
 def handler(event, context):
-    print(f"${SLACK_SLASH_COMMAND} - Event: {event}\n")
+    """
+    AWS Lambda entrypoint: Handles Slack requests via Slack Bolt's AWS adapter.
+    This function is called by AWS Lambda when the function is invoked.
+    """
+    logging.info(f"{SLACK_SLASH_COMMAND} - Event: {event}")
     slack_handler = SlackRequestHandler(app=app)
     return slack_handler.handle(event, context)

packages/slackBotFunction/requirements.txt

@@ -1,4 +1,5 @@
-slack-bolt==1.21.0
+slack-bolt==1.22.0
+slack-sdk==3.34.0
 boto3
 requests
 opensearch-py==2.4.2