fix

Author: Tricked-dev

src/event_handler.rs

@@ -106,20 +106,30 @@ pub async fn handle_event(
             if is_dm {
                 // Handle DM with rate limiting
                 if let Some(dm_limit_duration) = locked_state.dm_bucket.limit_duration(msg.author.id.get()) {
-                    tracing::info!("DM rate limit reached for user {}, {} seconds remaining", msg.author.id.get(), dm_limit_duration.as_secs());
+                    tracing::info!(
+                        "DM rate limit reached for user {}, {} seconds remaining",
+                        msg.author.id.get(),
+                        dm_limit_duration.as_secs()
+                    );
 
                     // Send a message to the user about the rate limit
                     let _ = http
                         .create_message(msg.channel_id)
-                        .content(&format!("You've reached the DM rate limit. Please wait {} seconds before sending more messages.", dm_limit_duration.as_secs()))?
+                        .content(&format!(
+                            "You've reached the DM rate limit. Please wait {} seconds before sending more messages.",
+                            dm_limit_duration.as_secs()
+                        ))?
                         .reply(msg.id)
                         .exec()
                         .await;
                     return Ok(());
                 }
 
                 // Track message count for memory creation using the DM user ID as key
-                let count = locked_state.channel_message_counts.entry(msg.author.id.get()).or_insert(0);
+                let count = locked_state
+                    .channel_message_counts
+                    .entry(msg.author.id.get())
+                    .or_insert(0);
                 *count += 1;
 
                 // Check if we should create memories (every 15 messages)
@@ -198,7 +208,10 @@ pub async fn handle_event(
             }
 
             // Increment message count for this channel
-            let count = locked_state.channel_message_counts.entry(msg.channel_id.get()).or_insert(0);
+            let count = locked_state
+                .channel_message_counts
+                .entry(msg.channel_id.get())
+                .or_insert(0);
             *count += 1;
 
             if let Some(today_i) = locked_state.config.today_i_channel {
@@ -245,7 +258,7 @@ pub async fn handle_event(
                         )
                         .exec()
                         .await?;
-                    } else {
+                    } else if text.is_some() || !embeds.is_empty() || !attachments.is_empty() {
                         let mut req = http
                             .create_message(msg.channel_id)
                             .embeds(&embeds)?

src/main.rs

@@ -63,7 +63,7 @@ async fn main() -> color_eyre::Result<()> {
 
     tracing_subscriber::fmt()
         .with_env_filter(tracing_subscriber::EnvFilter::new(
-            "debug,h2::codec::framed_read=off,twilight_gateway::shard=off,twilight_http_ratelimiting::in_memory=info,rustls::client=info,hyper::client::connect=info",
+            "debug,h2::codec::framed_read=off,twilight_gateway::shard=off,twilight_http_ratelimiting::in_memory=info,rustls::client=info,hyper::client::connect=info,h2::codec::framed_write=info",
         ))
         .init();
 

src/message_handler.rs

@@ -1,14 +1,29 @@
-use rand::{prelude::{IteratorRandom, SliceRandom}, seq::IndexedRandom, Rng};
+use rand::{
+    prelude::{IteratorRandom, SliceRandom},
+    seq::IndexedRandom,
+    Rng,
+};
 use serde_rusqlite::from_row;
 use std::{sync::Arc, time::Instant};
 use tokio::sync::{mpsc, MutexGuard};
 use twilight_http::Client as HttpClient;
-use twilight_model::{gateway::payload::incoming::MessageCreate, id::{marker::{ChannelMarker, MessageMarker}, Id}};
+use twilight_model::{
+    gateway::payload::incoming::MessageCreate,
+    id::{
+        marker::{ChannelMarker, MessageMarker},
+        Id,
+    },
+};
 use vesper::twilight_exports::UserMarker;
 
 use crate::{
-    ai_message, database::User, memory_creator, quiz_handler, structs::{Command, List, State},
-    utils::levels::xp_required_for_level, zalgos::zalgify_text, RESPONDERS,
+    ai_message,
+    database::User,
+    memory_creator, quiz_handler,
+    structs::{Command, List, State},
+    utils::levels::xp_required_for_level,
+    zalgos::zalgify_text,
+    RESPONDERS,
 };
 
 /// Handle streaming AI response with periodic updates
@@ -59,21 +74,19 @@ pub async fn handle_streaming_response(
         // Send initial message once we have enough words
         if message_id.is_none() && content.split_whitespace().count() >= MIN_WORDS {
             match http.create_message(channel_id).content(&content) {
-                Ok(req) => {
-                    match req.reply(reply_to).exec().await {
-                        Ok(response) => {
-                            if let Ok(msg) = response.model().await {
-                                message_id = Some(msg.id);
-                                last_sent_content = content.clone();
-                                last_update = Instant::now();
-                            }
-                        }
-                        Err(e) => {
-                            log::error!("Failed to send initial message: {:?}", e);
-                            return;
+                Ok(req) => match req.reply(reply_to).exec().await {
+                    Ok(response) => {
+                        if let Ok(msg) = response.model().await {
+                            message_id = Some(msg.id);
+                            last_sent_content = content.clone();
+                            last_update = Instant::now();
                         }
                     }
-                }
+                    Err(e) => {
+                        log::error!("Failed to send initial message: {:?}", e);
+                        return;
+                    }
+                },
                 Err(e) => {
                     log::error!("Failed to create message: {:?}", e);
                     return;
@@ -227,7 +240,8 @@ pub async fn handle_message(
             ) =>
         {
             // Check if we should create memories based on message count
-            let should_create_memory = locked_state.channel_message_counts
+            let should_create_memory = locked_state
+                .channel_message_counts
                 .get(&msg.channel_id.get())
                 .map(|count| *count >= 30)
                 .unwrap_or(false);
@@ -374,9 +388,15 @@ pub async fn handle_message(
                 .children
                 .into_iter()
                 .filter(|x| !x.data.over_18)
-                .filter(|x| x.data.url_overridden_by_dest.contains("i."))
+                .filter(|x| {
+                    x.data
+                        .url_overridden_by_dest
+                        .as_ref()
+                        .map(|url| url.contains("i."))
+                        .unwrap_or(false)
+                })
                 .choose(&mut locked_state.rng)
-                .map(|x| x.data.url_overridden_by_dest);
+                .and_then(|x| x.data.url_overridden_by_dest);
             if let Some(pic) = res {
                 Ok(Command::text(pic))
             } else {

src/structs.rs

@@ -191,7 +191,7 @@ pub struct Children {
 #[serde(rename_all = "camelCase")]
 pub struct Data2 {
     #[serde(rename = "url_overridden_by_dest")]
-    pub url_overridden_by_dest: String,
+    pub url_overridden_by_dest: Option<String>,
     #[serde(rename = "over_18")]
     pub over_18: bool,
 }