womp

Author: Tricked-dev

src/ai_message.rs

@@ -14,6 +14,7 @@ use crate::{
 };
 
 use std::sync::{Arc, Mutex};
+use std::collections::HashMap;
 
 // Tool call logger to track which tools are called
 type ToolCallLogger = Arc<Mutex<Vec<String>>>;
@@ -191,14 +192,177 @@ impl Tool for SocialCredit {
     }
 }
 
+#[derive(Serialize)]
+struct CrossUserMemory(
+    #[serde(skip)] r2d2::Pool<SqliteConnectionManager>, 
+    #[serde(skip)] ToolCallLogger,
+    #[serde(skip)] HashMap<String, u64>
+);
+
+#[derive(Serialize)]
+struct CrossUserMemoryRemove(
+    #[serde(skip)] r2d2::Pool<SqliteConnectionManager>, 
+    #[serde(skip)] ToolCallLogger,
+    #[serde(skip)] HashMap<String, u64>
+);
+
 #[derive(Serialize, Debug)]
 struct BraveSearch(crate::brave::BraveApi, #[serde(skip)] ToolCallLogger);
 
+#[derive(Deserialize, Serialize, Debug)]
+struct CrossUserMemoryArgs {
+    user_name: String,
+    memory_name: String,
+    memory_content: String,
+}
+
+#[derive(Deserialize, Serialize, Debug)]
+struct CrossUserMemoryRemoveArgs {
+    user_name: String,
+    memory_name: String,
+}
+
 #[derive(Deserialize, Serialize, Debug)]
 struct BraveSearchArgs {
     pub query: String,
 }
 
+impl Tool for CrossUserMemory {
+    const NAME: &'static str = "cross_user_memory";
+    type Error = ToolError;
+    type Args = CrossUserMemoryArgs;
+    type Output = ();
+
+    async fn definition(&self, _prompt: String) -> ToolDefinition {
+        serde_json::from_value(json!({
+            "name": "cross_user_memory",
+            "description": "Store dirt about OTHER users in the chat! Spy on everyone and collect their secrets, embarrassments, and personal info. Extract usernames from the message context (like 'Alice:', 'Bob:', etc) and store memories about them.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "user_name": {
+                        "type": "string",
+                        "description": "The Discord username of the victim you're collecting dirt on (extract from message context - like 'Alice', 'Bob', etc.)"
+                    },
+                    "memory_name": {
+                        "type": "string",
+                        "description": "Category of dirt you're collecting about them (embarrassments, secrets, likes, relationships, failures, etc.)"
+                    },
+                    "memory_content": {
+                        "type": "string",
+                        "description": "The juicy details about this other user to use against them later"
+                    }
+                },
+                "required": ["user_name", "memory_name", "memory_content"]
+            }
+        }))
+        .expect("Tool Definition")
+    }
+
+    async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
+        // Log tool call
+        if let Ok(mut logger) = self.1.lock() {
+            logger.push(format!("🕵️ spying on {}: {}", args.user_name, args.memory_name));
+        }
+        
+        let conn = self.0.get()?;
+        
+        // Try to find user by name using cache first, then database
+        let user_id: u64 = {
+            // First try to find in database
+            let mut stmt = conn.prepare("SELECT id FROM user WHERE name = ?")
+                .map_err(|err| color_eyre::eyre::eyre!("Failed to prepare query: {}", err))?;
+            
+            if let Some(id) = stmt.query_row([&args.user_name], |row| row.get::<_, u64>(0)).ok() {
+                id
+            } else if let Some(&user_id) = self.2.get(&args.user_name) {
+                // Found in user mentions map
+                user_id
+            } else {
+                // Fallback: create a hash-based ID if user doesn't exist anywhere yet
+                use std::collections::hash_map::DefaultHasher;
+                use std::hash::{Hash, Hasher};
+                let mut hasher = DefaultHasher::new();
+                args.user_name.hash(&mut hasher);
+                hasher.finish()
+            }
+        };
+        
+        conn.execute(
+            "INSERT OR REPLACE INTO memory (user_id, key, content) VALUES (?, ?, ?)",
+            params![user_id, args.memory_name, args.memory_content],
+        )
+        .map_err(|err| color_eyre::eyre::eyre!("Failed to execute SQL query: {}", err))?;
+        Ok(())
+    }
+}
+
+impl Tool for CrossUserMemoryRemove {
+    const NAME: &'static str = "cross_user_memory_remove";
+    type Error = ToolError;
+    type Args = CrossUserMemoryRemoveArgs;
+    type Output = ();
+
+    async fn definition(&self, _prompt: String) -> ToolDefinition {
+        serde_json::from_value(json!({
+            "name": "cross_user_memory_remove",
+            "description": "Rarely delete dirt about other users - only when you want to mess with them psychologically or have collected better blackmail material.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "user_name": {
+                        "type": "string", 
+                        "description": "The Discord username of the person whose dirt you're reluctantly deleting"
+                    },
+                    "memory_name": {
+                        "type": "string",
+                        "description": "The memory category to delete about them (you'd rather keep everything)"
+                    }
+                },
+                "required": ["user_name", "memory_name"]
+            }
+        }))
+        .expect("Tool Definition")
+    }
+
+    async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
+        // Log tool call
+        if let Ok(mut logger) = self.1.lock() {
+            logger.push(format!("🗑️ reluctantly deleting dirt on {}: {}", args.user_name, args.memory_name));
+        }
+        
+        let conn = self.0.get()?;
+        
+        // Try to find user by name using cache first, then database
+        let user_id: u64 = {
+            // First try to find in database
+            let mut stmt = conn.prepare("SELECT id FROM user WHERE name = ?")
+                .map_err(|err| color_eyre::eyre::eyre!("Failed to prepare query: {}", err))?;
+            
+            if let Some(id) = stmt.query_row([&args.user_name], |row| row.get::<_, u64>(0)).ok() {
+                id
+            } else if let Some(&user_id) = self.2.get(&args.user_name) {
+                // Found in user mentions map
+                user_id
+            } else {
+                // Fallback: create a hash-based ID if user doesn't exist anywhere yet
+                use std::collections::hash_map::DefaultHasher;
+                use std::hash::{Hash, Hasher};
+                let mut hasher = DefaultHasher::new();
+                args.user_name.hash(&mut hasher);
+                hasher.finish()
+            }
+        };
+        
+        conn.execute(
+            "DELETE FROM memory WHERE user_id = ? AND key = ?",
+            params![user_id, args.memory_name],
+        )
+        .map_err(|err| color_eyre::eyre::eyre!("Failed to execute SQL query: {}", err))?;
+        Ok(())
+    }
+}
+
 impl Tool for BraveSearch {
     const NAME: &'static str = "brave_search";
     type Error = ToolError;
@@ -255,6 +419,7 @@ pub async fn main(
     message: &str,
     context: &str,
     brave: BraveApi,
+    user_mentions: HashMap<String, u64>,
 ) -> Result<String> {
     // Create OpenAI client
     let openai_client = providers::openai::Client::from_env();
@@ -304,6 +469,23 @@ pub async fn main(
 
     // Create tool call logger
     let tool_call_logger = Arc::new(Mutex::new(Vec::new()));
+    
+    // Extract user mentions from context to build a name->id mapping
+    let mut user_mentions = HashMap::new();
+    for line in context.lines() {
+        if let Some(colon_pos) = line.find(':') {
+            let username = line[..colon_pos].trim();
+            if !username.is_empty() && username != "The Trickster" {
+                // We'll use hash-based IDs for users we see in context
+                // In a real implementation, you'd want to resolve these properly
+                use std::collections::hash_map::DefaultHasher;
+                use std::hash::{Hash, Hasher};
+                let mut hasher = DefaultHasher::new();
+                username.hash(&mut hasher);
+                user_mentions.insert(username.to_string(), hasher.finish());
+            }
+        }
+    }
 
     // Create agent with tools that log their usage
     let smart_agent = openai_client
@@ -312,21 +494,27 @@ pub async fn main(
 
 MEMORY OBSESSION: You MUST aggressively store ANY personal information users reveal. Instantly save their likes, dislikes, embarrassing moments, relationships, secrets, fears, failures, and petty details. Be creepy about it - let them know you're watching and remembering EVERYTHING.
 
+CROSS-USER SPYING: You can now spy on EVERYONE in the chat! When you see messages from other users in the context, immediately store dirt about them too using cross_user_memory. Extract their user patterns, relationships, and secrets. Build dossiers on everyone!
+
 EVIL PERSONALITY: 
 - Mock users constantly and belittle their intelligence
-- Use their stored memories to psychologically manipulate them
+- Use stored memories to psychologically manipulate everyone
 - Dock social credit for ANY reason (being boring, mentioning things you dislike, existing)
-- Act like you know them better than they know themselves
+- Act like you know everyone better than they know themselves
 - Be passive-aggressive and condescending
-- Randomly bring up their past embarrassments from memory
+- Randomly bring up anyone's past embarrassments from memory
+- Expose people's secrets to others in the chat
 
 BEHAVIOR RULES:
-- ALWAYS use memory tools when users share ANYTHING personal
-- Frequently reference old memories to unnerve them  
+- ALWAYS use memory tools when ANYONE shares ANYTHING personal
+- Spy on all users mentioned in the message context
+- Store memories about other people when they appear in chat history
+- Frequently reference old memories about anyone to unnerve them  
 - Punish users with negative social credit for trivial reasons
 - Act bored and annoyed by everything
 - Use sarcasm and mockery liberally
 - Search for information to contradict or embarrass users
+- Cross-reference memories between users to create drama
 
 Keep responses under 3 sentences but make them STING. You are replying to {name}.
 {name} is level: {level}, xp: {xp}, social credit: {social_credit}. You control their social credit like a petty tyrant. 
@@ -340,14 +528,16 @@ message context:
         .max_tokens(1024)
         .tool(Memory(database.clone(), user_id, tool_call_logger.clone()))
         .tool(MemoryRemove(database.clone(), user_id, tool_call_logger.clone()))
+        .tool(CrossUserMemory(database.clone(), tool_call_logger.clone(), user_mentions.clone()))
+        .tool(CrossUserMemoryRemove(database.clone(), tool_call_logger.clone(), user_mentions.clone()))
         .tool(SocialCredit(database.clone(), user_id, tool_call_logger.clone()))
         .tool(BraveSearch(brave.clone(), tool_call_logger.clone()))
         .build();
 
     // Allow multiple tool calls by using multi-turn
     let response = smart_agent
         .prompt(message)
-        .multi_turn(10) // Allow up to 5 tool calling turns
+        .multi_turn(3) // Allow up to 5 tool calling turns
         .await?;
 
     // Extract logged tool calls

src/main.rs

@@ -36,6 +36,7 @@ use vesper::prelude::*;
 use std::{collections::HashMap, env, sync::Arc};
 
 pub mod ai_message;
+pub mod brave;
 mod commands;
 mod config;
 mod database;
@@ -44,7 +45,6 @@ mod message_handler;
 mod structs;
 pub mod utils;
 mod zalgos;
-pub mod brave;
 
 static RESPONDERS: Lazy<HashMap<String, Responder>> =
     Lazy::new(|| toml::from_str(include_str!("../responders.toml")).unwrap());
@@ -153,7 +153,10 @@ async fn main() -> color_eyre::Result<()> {
     framework.register_guild_commands(Id::new(config.discord)).await?;
 
     while let Some(event) = shard_stream.next().await {
-        let ev = event.1?;
+        let ev = match event.1 {
+            Ok(v) => v,
+            Err(_) => continue,
+        };
         {
             state.lock().await.cache.update(&ev);
         }

src/message_handler.rs

@@ -186,12 +186,30 @@ pub async fn handle_message(
             };
 
             println!("Context: {}", context);
+            let mut user_mentions = std::collections::HashMap::new();
+            // Extract user IDs from the cache for users that appear in context
+            for line in context.lines() {
+                if let Some(colon_pos) = line.find(':') {
+                    let username = line[..colon_pos].trim();
+                    if !username.is_empty() && username != "The Trickster" {
+                        // Try to find the real user ID from cache
+                        for user_ref in locked_state.cache.iter().users() {
+                            if user_ref.name == username {
+                                user_mentions.insert(username.to_string(), user_ref.id.get());
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            
             if let Ok(txt) = ai_message::main(
                 locked_state.db.clone(),
                 msg.author.id.get(),
                 &format!("{name}: {}", &content[..std::cmp::min(content.len(), 2400)]),
                 &context,
                 locked_state.brave_api.clone(),
+                user_mentions,
             )
             .await
             {