feat: サブスクライバー限定で GPT-4 を解放 (#59)

src/client/openai.rs

@@ -54,9 +54,9 @@ fn init_client(api_key: &str, model: Option<ChatGPTEngine>) -> anyhow::Result<Ch
 /// * 2000文字を超過する
 pub async fn request_message(
     content: String,
-    model: Option<ChatGPTEngine>,
+    model: ChatGPTEngine,
 ) -> anyhow::Result<CompletionResponse> {
-    let client = init_client(OPENAI_API_KEY.as_str(), model)?;
+    let client = init_client(OPENAI_API_KEY.as_str(), Some(model))?;
 
     let response = match timeout(TIMEOUT_DURATION, client.send_message(content)).await {
         Ok(result) => result.context("Failed to communicate with ChatGPT")?,
@@ -82,9 +82,9 @@ pub async fn request_message(
 /// [String]: ChatGPT からのレスポンス
 pub async fn request_reply_message(
     reply_messages: &[ReplyMessage],
-    model: Option<ChatGPTEngine>,
+    model: ChatGPTEngine,
 ) -> anyhow::Result<String> {
-    let client = init_client(OPENAI_API_KEY.as_str(), model)?;
+    let client = init_client(OPENAI_API_KEY.as_str(), Some(model))?;
 
     let history = reply_messages
         .iter()

src/event.rs

@@ -1,19 +1,23 @@
 use crate::client::discord::EvHandler;
 use crate::service::chat::chat_mode;
 use crate::service::reply::reply_mode;
+use chatgpt::prelude::ChatGPTEngine;
 use serenity::async_trait;
 use serenity::client::Context;
 use serenity::http::{Http, Typing};
 use serenity::model::channel::Message;
 use serenity::model::gateway::Ready;
 use serenity::model::id::ChannelId;
-use serenity::model::prelude::{Activity, MessageType};
+use serenity::model::prelude::{Activity, GuildId, MessageType, RoleId};
 use serenity::prelude::EventHandler;
 use std::sync::Arc;
 use tracing::log::{error, info};
 
-const VERSION: &str = env!("CARGO_PKG_VERSION");
-const ADMINISTRATOR: u64 = 586824421470109716;
+static VERSION: &str = env!("CARGO_PKG_VERSION");
+static ADMINISTRATOR: u64 = 586824421470109716;
+// 変わることはそうそうないので、定数化
+static APPROVERS_ID: GuildId = GuildId(683939861539192860);
+static SUBSCRIPTION_ROLE_ID: RoleId = RoleId(709699920730390559);
 
 #[async_trait]
 impl EventHandler for EvHandler {
@@ -35,10 +39,21 @@ impl EventHandler for EvHandler {
         );
         let typing = start_typing(http, channel_id);
 
+        let is_subscriber = new_msg
+            .author
+            .has_role(&ctx, APPROVERS_ID, SUBSCRIPTION_ROLE_ID)
+            .await
+            .unwrap();
+        let model = if is_subscriber {
+            ChatGPTEngine::Gpt4
+        } else {
+            ChatGPTEngine::Gpt35Turbo
+        };
+
         match new_msg.kind {
             // 通常メッセージ (チャットモード)
             MessageType::Regular => {
-                if let Err(why) = chat_mode(&ctx, &new_msg).await {
+                if let Err(why) = chat_mode(&ctx, &new_msg, model).await {
                     let _ = new_msg
                         .reply(
                             &ctx,
@@ -53,7 +68,7 @@ impl EventHandler for EvHandler {
             }
             // 返信 (リプライモード)
             MessageType::InlineReply => {
-                if let Err(why) = reply_mode(&ctx, &new_msg).await {
+                if let Err(why) = reply_mode(&ctx, &new_msg, model).await {
                     let _ = new_msg
                         .reply(
                             &ctx,

src/service/chat.rs

@@ -1,26 +1,31 @@
+use chatgpt::prelude::ChatGPTEngine;
 use chatgpt::types::CompletionResponse;
 use once_cell::sync::OnceCell;
 use serenity::model::prelude::Message;
 use serenity::prelude::Context;
 
 use crate::client::openai::request_message;
 
-pub async fn chat_mode(ctx: &Context, msg: &Message) -> anyhow::Result<()> {
-    let response = get_response(ctx, msg).await?;
+pub async fn chat_mode(ctx: &Context, msg: &Message, model: ChatGPTEngine) -> anyhow::Result<()> {
+    let response = get_response(ctx, msg, model).await?;
     let reply_content = &response.message().content;
 
     msg.reply(ctx, reply_content).await?;
 
     Ok(())
 }
 
-async fn get_response(ctx: &Context, msg: &Message) -> anyhow::Result<CompletionResponse> {
+async fn get_response(
+    ctx: &Context,
+    msg: &Message,
+    model: ChatGPTEngine,
+) -> anyhow::Result<CompletionResponse> {
     static OWN_MENTION: OnceCell<String> = OnceCell::new();
     let mention = OWN_MENTION.get_or_init(|| format!("<@{}>", ctx.cache.current_user_id()));
 
     let content = msg.content.replace(mention, "").trim().to_string();
 
-    let response = request_message(content, None).await?;
+    let response = request_message(content, model).await?;
 
     Ok(response)
 }

src/service/reply.rs

@@ -1,13 +1,14 @@
 use crate::client::openai::request_reply_message;
 use crate::model::{ReplyMessage, ReplyRole};
+use chatgpt::prelude::ChatGPTEngine;
 use once_cell::sync::OnceCell;
 use serenity::model::prelude::Message;
 use serenity::prelude::Context;
 
-pub async fn reply_mode(ctx: &Context, msg: &Message) -> anyhow::Result<()> {
+pub async fn reply_mode(ctx: &Context, msg: &Message, model: ChatGPTEngine) -> anyhow::Result<()> {
     let replies = get_replies(ctx, msg).await?;
     // notes: GPT-4 があまりにも高いため、GPT-3.5 に revert
-    let response_message = request_reply_message(&replies, None).await?;
+    let response_message = request_reply_message(&replies, model).await?;
 
     msg.reply(ctx, response_message).await?;