Slack(メンション)
  ↓ Events API(HTTP POST)
Lambda関数URL
  ↓
受付Lambda――署名検証して即200 OKを返す
  ↓ 非同期Invoke
処理Lambda――Bedrockで要約を生成
  ↓ chat.postMessage
Slack(スレッドに返信)

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "bedrock:InvokeModel",
      "Resource": "*"
    }
  ]
}

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "lambda:InvokeFunction",
      "Resource": "arn:aws:lambda:ap-northeast-1:123456789012:function:slack-summary-process"
    }
  ]
}

"""処理Lambda(Slack版):Bedrockで要約し、chat.postMessageでスレッドに返信する。

"""
import json
import os
import re
import urllib.request

import boto3

bedrock = boto3.client("bedrock-runtime")

SLACK_BOT_TOKEN = os.environ["SLACK_BOT_TOKEN"]
MODEL_ID = os.environ["MODEL_ID"]

SYSTEM_PROMPT = (
    "あなたは要約アシスタントです。送られてきた文章を、"
    "重要なポイントを落とさずに3行以内の日本語で要約してください。"
    "前置きや補足は不要で、要約本文だけを返してください。"
)

def summarize(text: str) -> str:
    """Bedrock Converse APIで要約を生成する"""
    response = bedrock.converse(
        modelId=MODEL_ID,
        system=[{"text": SYSTEM_PROMPT}],
        messages=[{"role": "user", "content": [{"text": text}]}],
        inferenceConfig={"maxTokens": 500, "temperature": 0.3},
    )
    return response["output"]["message"]["content"][0]["text"]

def post_to_slack(channel: str, thread_ts: str, text: str) -> None:
    """chat.postMessageで元メッセージのスレッドに返信する"""
    req = urllib.request.Request(
        "https://slack.com/api/chat.postMessage",
        data=json.dumps(
            {"channel": channel, "thread_ts": thread_ts, "text": text}
        ).encode("utf-8"),
        headers={
            "Content-Type": "application/json; charset=utf-8",
            "Authorization": f"Bearer {SLACK_BOT_TOKEN}",
        },
        method="POST",
    )
    with urllib.request.urlopen(req) as res:
        result = json.loads(res.read())
    # Slackは失敗でもHTTP200を返すので、okフィールドで判定する
    if not result.get("ok"):
        raise RuntimeError(f"Slack API error: {result.get('error')}")

def lambda_handler(event, context):
    channel = event["channel"]
    thread_ts = event["thread_ts"]
    # メンション部分(<@U12345678>)を除去して本文だけにする
    text = re.sub(r"<@[A-Z0-9]+>", "", event["text"]).strip()

    if not text:
        post_to_slack(channel, thread_ts, "要約したい文章と一緒にメンションしてください。")
        return {"statusCode": 200}

    try:
        summary = summarize(text)
    except Exception as e:
        print(f"Bedrock error: {e}")
        summary = "ごめんなさい、要約に失敗しました。もう一度試してください。"

    post_to_slack(channel, thread_ts, summary)
    return {"statusCode": 200}

{
  "channel": "dummy",
  "thread_ts": "1",
  "text": "これはテストです。LambdaからBedrockを呼び出せるか確認しています。"
}

"""受付Lambda(Slack版):Events APIのWebhookを受け、署名検証して即200を返す。

環境変数:
  SLACK_SIGNING_SECRET :SlackアプリのSigning Secret
  PROCESS_FUNCTION_NAME:処理Lambdaの関数名
"""
import hashlib
import hmac
import json
import os
import time

import boto3

lambda_client = boto3.client("lambda")

SLACK_SIGNING_SECRET = os.environ["SLACK_SIGNING_SECRET"]
PROCESS_FUNCTION_NAME = os.environ["PROCESS_FUNCTION_NAME"]

def verify_signature(body: str, timestamp: str, signature: str) -> bool:
    """x-slack-signatureヘッダを検証する"""
    if not timestamp or not signature:
        return False
    # リプレイ攻撃対策:5分以上古いリクエストは拒否
    if abs(time.time() - int(timestamp)) > 60 * 5:
        return False
    base = f"v0:{timestamp}:{body}"
    digest = hmac.new(
        SLACK_SIGNING_SECRET.encode("utf-8"),
        base.encode("utf-8"),
        hashlib.sha256,
    ).hexdigest()
    return hmac.compare_digest(f"v0={digest}", signature)

def lambda_handler(event, context):
    body = event.get("body", "")
    headers = {k.lower(): v for k, v in (event.get("headers") or {}).items()}

    if not verify_signature(
        body,
        headers.get("x-slack-request-timestamp", ""),
        headers.get("x-slack-signature", ""),
    ):
        return {"statusCode": 403, "body": "invalid signature"}

    payload = json.loads(body)

    # 初回のURL検証:challengeをそのまま返す
    if payload.get("type") == "url_verification":
        return {
            "statusCode": 200,
            "headers": {"Content-Type": "application/json"},
            "body": json.dumps({"challenge": payload["challenge"]}),
        }

    # Slackのリトライは処理済みの可能性が高いので無視(要約の重複防止)
    if "x-slack-retry-num" in headers:
        return {"statusCode": 200, "body": "ok (retry ignored)"}

    ev = payload.get("event", {})

    # ボット自身の投稿には反応しない(無限ループ防止)
    if ev.get("bot_id") or ev.get("subtype") == "bot_message":
        return {"statusCode": 200, "body": "ok (bot message ignored)"}

    if ev.get("type") == "app_mention":
        lambda_client.invoke(
            FunctionName=PROCESS_FUNCTION_NAME,
            InvocationType="Event",  # 非同期:応答を待たない
            Payload=json.dumps(
                {
                    "channel": ev["channel"],
                    "thread_ts": ev.get("thread_ts") or ev["ts"],
                    "text": ev.get("text", ""),
                }
            ).encode("utf-8"),
        )

    # Slackには即座に200を返す(3秒ルール)
    return {"statusCode": 200, "body": "ok"}

    except Exception as e:
        print(f"Bedrock error: {e}")
        summary = f"[デバッグ] エラー詳細: {type(e).__name__}: {e}"