SlackおしゃべりBotの内部をOpenAI APIからAWS Bedrockに移行した

{
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["lambda:InvokeFunction"],
      "Resource": "arn:aws:lambda:*:*:function:slack-bot-processor"
    },
    {
      "Effect": "Allow",
      "Action": ["logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents"],
      "Resource": "*"
    }
  ]
}

import json
import boto3
import hashlib
import hmac
import os
import time

lambda_client = boto3.client('lambda')

def verify_slack_signature(headers: dict, body: str, signing_secret: str) -> bool:
    """Slackリクエストの署名検証"""
    timestamp = headers.get('X-Slack-Request-Timestamp', '')
    # リプレイアタック防止（5分以上古いリクエストを拒否）
    if abs(time.time() - int(timestamp)) > 300:
        return False
    sig_basestring = f"v0:{timestamp}:{body}"
    my_signature = 'v0=' + hmac.new(
        signing_secret.encode(),
        sig_basestring.encode(),
        hashlib.sha256
    ).hexdigest()
    slack_signature = headers.get('X-Slack-Signature', '')
    return hmac.compare_digest(my_signature, slack_signature)

def lambda_handler(event, context):
    headers = event.get('headers', {})
    body_str = event.get('body', '{}')
    
    # Slackのリトライを無視（重複処理防止）
    if headers.get('X-Slack-Retry-Num'):
        return {'statusCode': 200, 'body': json.dumps({'status': 'ignored retry'})}
    
    body = json.loads(body_str)
    
    # Slack URL Verification（初回設定時）
    if body.get('type') == 'url_verification':
        return {'statusCode': 200, 'body': json.dumps({'challenge': body['challenge']})}
    
    # Lambda #2 を非同期で呼び出し
    lambda_client.invoke(
        FunctionName='slack-bot-processor',
        InvocationType='Event',  # 非同期呼び出し（レスポンスを待たない）
        Payload=json.dumps(body)
    )
    
    # Slackへ即座に200を返却
    return {'statusCode': 200, 'body': json.dumps({'status': 'ok'})}

{
	"Version": "2012-10-17",
	"Statement": [
		{
			"Sid": "BedrockInvoke",
			"Effect": "Allow",
			"Action": [
				"bedrock:InvokeModel"
			],
			"Resource": "arn:aws:bedrock:*::foundation-model/*"
		},
		{
			"Sid": "CloudWatchLogs",
			"Effect": "Allow",
			"Action": [
				"logs:CreateLogGroup",
				"logs:CreateLogStream",
				"logs:PutLogEvents"
			],
			"Resource": "*"
		},
		{
			"Sid": "SecretsManagerRead",
			"Effect": "Allow",
			"Action": [
				"secretsmanager:GetSecretValue",
				"secretsmanager:DescribeSecret"
			],
			"Resource": "arn:aws:secretsmanager:*:*:secret:*"
		}
	]
}

import json
import boto3
import urllib.request
import os

bedrock = boto3.client('bedrock-runtime', region_name='ap-northeast-1')
ssm = boto3.client('secretsmanager')

def get_slack_token() -> str:
    secret = ssm.get_secret_value(SecretId='slack-bot/tokens')
    return json.loads(secret['SecretString'])['bot_token']

def get_thread_history(channel: str, thread_ts: str, token: str, limit: int = 20) -> list:
    """
    Slackスレッドの履歴を取得し、Bedrock用のmessages配列に変換
    戻り値: [{"role": "user"/"assistant", "content": [{"text": "..."}]}, ...]
    """
    url = (
        f"https://slack.com/api/conversations.replies"
        f"?channel={channel}&ts={thread_ts}&limit={limit}"
    )
    req = urllib.request.Request(
        url,
        headers={'Authorization': f'Bearer {token}'}
    )
    with urllib.request.urlopen(req) as res:
        data = json.loads(res.read())

    if not data.get('ok'):
        # 履歴取得失敗時は空リストを返して処理継続
        return []

    messages = []
    for msg in data.get('messages', []):
        text = msg.get('text', '').strip()
        if not text:
            continue

        # Bot発言 → assistant / それ以外 → user
        role = 'assistant' if msg.get('bot_id') else 'user'
        messages.append({
            'role': role,
            'content': [{'text': text}]
        })

    return messages

def call_bedrock(user_message: str, history: list = None) -> str:
    """
    Amazon Nova Lite を呼び出し
    history: Threadの過去メッセージ（Bedrock形式）
    """
    if history:
        # 履歴あり: 過去メッセージ + 最新メンションを結合
        # ※ 最後のメッセージが最新のメンションなので重複を避けるため
        #   historyの末尾がすでに同じ内容の場合はそのまま使う
        messages = history
        # historyの最後がuserかつ同一メッセージでなければ追加
        if not messages or messages[-1].get('content', [{}])[0].get('text') != user_message:
            messages.append({
                'role': 'user',
                'content': [{'text': user_message}]
            })
    else:
        # 履歴なし: 通常の単発質問
        messages = [
            {
                'role': 'user',
                'content': [{'text': user_message}]
            }
        ]

    payload = {
        'messages': messages,
        'inferenceConfig': {
            'maxTokens': 1024,
            'temperature': 0.7
        }
    }
    response = bedrock.invoke_model(
        modelId='amazon.nova-lite-v1:0',
        body=json.dumps(payload),
        contentType='application/json'
    )
    result = json.loads(response['body'].read())
    return result['output']['message']['content'][0]['text']

def post_to_slack(channel: str, text: str, thread_ts: str = None):
    """Slack APIへメッセージを投稿"""
    token = get_slack_token()
    payload = {'channel': channel, 'text': text}
    if thread_ts:
        payload['thread_ts'] = thread_ts
    req = urllib.request.Request(
        'https://slack.com/api/chat.postMessage',
        data=json.dumps(payload).encode(),
        headers={
            'Authorization': f'Bearer {token}',
            'Content-Type': 'application/json'
        }
    )
    urllib.request.urlopen(req)

def lambda_handler(event, context):
    channel = None
    try:
        slack_event = event.get('event', {})

        if slack_event.get('type') != 'app_mention':
            return
        if slack_event.get('bot_id'):
            return

        user_message = slack_event.get('text', '')
        channel = slack_event.get('channel')
        event_ts = slack_event.get('ts')         # このメッセージ自身のts
        thread_ts = slack_event.get('thread_ts') # スレッド親のts（Thread内のみ存在）

        token = get_slack_token()

        if thread_ts:
            # Thread内メンション: 履歴を取得してBedrockに渡す
            history = get_thread_history(channel, thread_ts, token, limit=20)
            response_text = call_bedrock(user_message, history)
            # 返信はスレッド内に投稿
            post_to_slack(channel, response_text, thread_ts=thread_ts)
        else:
            # 通常メンション（Thread外）: 従来通り
            response_text = call_bedrock(user_message)
            post_to_slack(channel, response_text, thread_ts=event_ts)

    except Exception as e:
        if channel:
            try:
                post_to_slack(channel, "⚠️ エラーが発生しました。しばらく後にお試しください。")
            except:
                pass
        raise e