Upload 7 files

README.md

@@ -1,12 +1,104 @@
----
-title: Jade Assistant
-emoji: 🌍
-colorFrom: purple
-colorTo: red
-sdk: gradio
-sdk_version: 6.2.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Jade Personal Assistant
+emoji: 🌿
+colorFrom: green
+colorTo: indigo
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+---
+
+# 🌿 Jade - 24h Personal Assistant
+
+Jade is a Telegram bot powered by **Hermes 4 405B** (via Chutes.ai) that acts as your personal assistant.
+
+## Features
+
+- 💬 **Natural conversation** - Chat naturally with Jade
+- ⏰ **Reminders** - Set reminders that persist across restarts
+- 🔍 **Web search** - Ask Jade to search the internet
+- 📅 **Time awareness** - Jade knows the current date/time
+
+## Setup on HuggingFace Spaces
+
+### 1. Create a new Space
+
+1. Go to [huggingface.co/new-space](https://huggingface.co/new-space)
+2. Choose **Gradio** as the SDK
+3. Select **Free** tier (CPU basic)
+
+### 2. Configure Secrets
+
+Go to **Settings > Repository secrets** and add:
+
+| Secret Name | Description |
+|------------|-------------|
+| `TELEGRAM_BOT_TOKEN` | Your Telegram bot token from @BotFather |
+| `CHUTES_API_KEY` | Your Chutes.ai API key |
+| `HF_TOKEN` | (Optional) Your HuggingFace token for persistent storage |
+| `HF_STORAGE_REPO` | (Optional) Dataset repo for storage, e.g., `username/jade-data` |
+
+### 3. Upload Files
+
+Upload all files from this directory to your Space:
+- `app.py` (entry point)
+- `main.py`
+- `core.py`
+- `tools.py`
+- `hf_storage.py`
+- `requirements.txt`
+
+### 4. Create Storage Dataset (Optional)
+
+For persistent reminders across Space restarts:
+
+1. Create a new private dataset at [huggingface.co/new-dataset](https://huggingface.co/new-dataset)
+2. Name it something like `jade-data`
+3. Set `HF_STORAGE_REPO` secret to `yourusername/jade-data`
+4. Make sure `HF_TOKEN` has write access to the dataset
+
+## Usage
+
+1. Find your bot on Telegram
+2. Send `/start` to begin
+3. Chat naturally!
+
+### Example commands:
+- "Remind me to call mom in 30 minutes"
+- "What's the weather in São Paulo?"
+- "What time is it?"
+- "List my reminders"
+
+## ⚠️ Important Notes
+
+- **Free tier hibernation**: The Space may sleep after ~15 min of inactivity. Reminders scheduled during sleep may be delayed.
+- **Wakeup**: Just access the Space URL or send a message to wake it up.
+
+## Architecture
+
+```
+┌────────────────────────────────────────────┐
+│           HuggingFace Space                │
+│  ┌──────────────┐    ┌─────────────────┐   │
+│  │   Gradio     │    │  Telegram Bot   │   │
+│  │  (Status UI) │    │   (main.py)     │   │
+│  └──────────────┘    └────────┬────────┘   │
+│                               │            │
+│                      ┌────────▼────────┐   │
+│                      │   Jade Agent    │   │
+│                      │   (core.py)     │   │
+│                      └────────┬────────┘   │
+│                               │            │
+│        ┌──────────────────────┼───────┐    │
+│        ▼                      ▼       ▼    │
+│  ┌──────────┐          ┌──────────┐ ┌───┐  │
+│  │ Chutes.ai│          │HF Storage│ │DDG│  │
+│  │(Hermes4) │          │(Dataset) │ │Web│  │
+│  └──────────┘          └──────────┘ └───┘  │
+└────────────────────────────────────────────┘
+```
+
+## License
+
+MIT

app.py

@@ -0,0 +1,115 @@
+"""
+HuggingFace Spaces Entry Point for Jade Bot
+
+This creates a minimal Gradio interface alongside the Telegram bot.
+The Gradio interface helps keep the Space awake and provides a status page.
+"""
+import os
+import sys
+import logging
+import threading
+import gradio as gr
+from datetime import datetime
+
+# Configure logging
+logging.basicConfig(
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    level=logging.INFO
+)
+logger = logging.getLogger(__name__)
+
+# Bot status tracking
+bot_status = {
+    "started_at": None,
+    "last_activity": None,
+    "messages_processed": 0,
+    "is_running": False
+}
+
+
+def run_telegram_bot():
+    """Run the Telegram bot in a separate thread."""
+    global bot_status
+    
+    try:
+        # Import here to avoid circular imports
+        from main import application, reminder_manager, agent
+        
+        bot_status["started_at"] = datetime.now().isoformat()
+        bot_status["is_running"] = True
+        
+        logger.info("Starting Telegram bot...")
+        application.run_polling()
+        
+    except Exception as e:
+        logger.error(f"Bot error: {e}")
+        bot_status["is_running"] = False
+
+
+def get_status():
+    """Return current bot status as formatted string."""
+    if not bot_status["is_running"]:
+        return "🔴 Bot is not running"
+    
+    status_text = f"""
+## 🟢 Jade Bot Status
+
+- **Started at**: {bot_status.get('started_at', 'N/A')}
+- **Last activity**: {bot_status.get('last_activity', 'N/A')}
+- **Status**: Running ✅
+
+### Configuration
+- **Model**: NousResearch/Hermes-4-405B-FP8-TEE
+- **API**: Chutes.ai
+- **Persistence**: HuggingFace Datasets
+
+---
+*Refresh this page to update status*
+"""
+    return status_text
+
+
+def create_gradio_interface():
+    """Create the Gradio status interface."""
+    with gr.Blocks(title="Jade Bot Status", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 🌿 Jade - 24h Personal Assistant")
+        gr.Markdown("This is the status page for Jade, your Telegram assistant.")
+        
+        status_display = gr.Markdown(get_status)
+        
+        refresh_btn = gr.Button("🔄 Refresh Status")
+        refresh_btn.click(fn=get_status, outputs=status_display)
+        
+        gr.Markdown("""
+        ### How to use
+        1. Find Jade on Telegram (your bot username)
+        2. Send `/start` to begin
+        3. Chat naturally - Jade can set reminders, search the web, and more!
+        """)
+    
+    return demo
+
+
+def main():
+    """Main entry point."""
+    # Check required environment variables
+    required_vars = ["TELEGRAM_BOT_TOKEN", "CHUTES_API_KEY"]
+    missing = [v for v in required_vars if not os.getenv(v)]
+    
+    if missing:
+        logger.error(f"Missing required environment variables: {missing}")
+        logger.error("Please set these in HuggingFace Space Secrets")
+        sys.exit(1)
+    
+    # Start Telegram bot in background thread
+    bot_thread = threading.Thread(target=run_telegram_bot, daemon=True)
+    bot_thread.start()
+    logger.info("Bot thread started")
+    
+    # Create and launch Gradio interface
+    demo = create_gradio_interface()
+    demo.launch(server_name="0.0.0.0", server_port=7860)
+
+
+if __name__ == "__main__":
+    main()

core.py

@@ -0,0 +1,174 @@
+import json
+import logging
+import re
+import os
+from openai import OpenAI
+from .tools import get_current_datetime, search_web, ReminderManager
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+class TelegramJadeAgent:
+    def __init__(self, reminder_manager=None, config_path="telegram_jade/config.json"):
+        # Simple config loading
+        self.config = {}
+        if os.path.exists(config_path):
+            with open(config_path) as f:
+                self.config = json.load(f)
+        
+        # Chutes.ai API with Hermes 405B model
+        self.model = self.config.get("model", "NousResearch/Hermes-4-405B-FP8-TEE")
+        self.client = OpenAI(
+            api_key=os.getenv("CHUTES_API_KEY"),
+            base_url="https://api.chutes.ai/v1"
+        )
+        
+        self.reminder_manager = reminder_manager if reminder_manager else ReminderManager()
+        
+        # Initialize storage for conversation history
+        try:
+            from .hf_storage import get_storage
+        except ImportError:
+            from hf_storage import get_storage
+        self.storage = get_storage()
+        
+        # Load persisted conversation history
+        self.histories = self.storage.load_json("conversation_history.json", default={})
+
+    def _get_system_prompt(self):
+        current_time = get_current_datetime()
+        return f"""You are Jade, a 24h personal assistant on Telegram.
+Current Time: {current_time}
+
+Your goal is to be helpful, manage reminders, and search the web when needed.
+You have a personality: friendly, efficient, and slightly witty.
+
+AVAILABLE TOOLS:
+You can call tools by responding ONLY with a JSON block in this format:
+{{"tool": "tool_name", "args": {{"arg1": "value1"}}}}
+
+Tools:
+1. get_current_datetime() -> Returns current date/time.
+2. search_web(query: str) -> Search internet for info.
+3. schedule_reminder(time_str: str, message: str) -> Schedule a reminder. 
+   - time_str MUST be in "YYYY-MM-DD HH:MM:SS" format. 
+   - If the user gives a relative time (e.g., "in 10 mins"), CALCULATE the absolute time based on Current Time.
+4. list_reminders() -> List pending reminders for the user.
+5. delete_reminder(reminder_id: int) -> Delete a reminder.
+
+RULES:
+- Always check the Current Time before scheduling.
+- If the user asks for a reminder, you MUST calculate the exact "YYYY-MM-DD HH:MM:SS" and use `schedule_reminder`.
+- If you need to answer a question about recent events, use `search_web`.
+- If you are just chatting, reply with plain text.
+"""
+
+    def _get_history(self, chat_id):
+        chat_id_str = str(chat_id)  # JSON keys must be strings
+        if chat_id_str not in self.histories:
+            self.histories[chat_id_str] = [{"role": "system", "content": self._get_system_prompt()}]
+        else:
+            # Update system prompt with fresh time
+            self.histories[chat_id_str][0]["content"] = self._get_system_prompt()
+        return self.histories[chat_id_str]
+
+    def _process_tool_call(self, response_text):
+        try:
+            match = re.search(r'\{.*\}', response_text, re.DOTALL)
+            if not match:
+                return None
+            data = json.loads(match.group(0))
+            if "tool" in data and "args" in data:
+                return data
+        except:
+            pass
+        return None
+
+    def _run_tool(self, tool_data, chat_id):
+        name = tool_data["tool"]
+        args = tool_data["args"]
+        
+        logger.info(f"Executing tool {name} for chat {chat_id}")
+
+        if name == "get_current_datetime":
+            return get_current_datetime()
+        elif name == "search_web":
+            return search_web(args.get("query"))
+        elif name == "schedule_reminder":
+            # We need to hook this into the actual scheduler in main.py.
+            # Ideally, the Agent should return this intent to the Main loop, 
+            # or the ReminderManager handles the DB and Main loop watches the DB.
+            # For simplicity: Agent updates DB via ReminderManager. 
+            # Main loop (Scheduler) should refresh or listen to changes.
+            # BUT: `schedule_reminder` here just updates the JSON. 
+            # The Scheduler in `main.py` needs to be aware of new jobs.
+            # We will return a special signal or just update the DB and assume Main reloads or we return a callback result.
+            return self.reminder_manager.add_reminder(chat_id, args.get("time_str"), args.get("message"))
+        elif name == "list_reminders":
+            return self.reminder_manager.list_reminders(chat_id)
+        elif name == "delete_reminder":
+            return self.reminder_manager.delete_reminder(chat_id, int(args.get("reminder_id")))
+        else:
+            return f"Unknown tool: {name}"
+
+    def chat(self, chat_id, user_input):
+        history = self._get_history(chat_id)
+        history.append({"role": "user", "content": user_input})
+        
+        # Simple ReAct loop
+        for _ in range(5):
+            try:
+                completion = self.client.chat.completions.create(
+                    messages=history,
+                    model=self.model,
+                    temperature=0.5
+                )
+                response = completion.choices[0].message.content
+            except Exception as e:
+                return f"Error calling Chutes.ai API: {e}"
+
+            tool_data = self._process_tool_call(response)
+            
+            if tool_data:
+                history.append({"role": "assistant", "content": response})
+                
+                tool_result = self._run_tool(tool_data, chat_id)
+                
+                history.append({"role": "system", "content": f"TOOL_RESULT: {tool_result}"})
+                
+                # If it was a reminder scheduling, we might want to inform the caller (main.py) 
+                # to update the scheduler.
+                # For now, we just continue the conversation loop.
+            else:
+                history.append({"role": "assistant", "content": response})
+                
+                # Limit history size
+                if len(history) > 20:
+                    history = [history[0]] + history[-19:]
+                self.histories[str(chat_id)] = history
+                
+                # Persist conversation history
+                self.storage.save_json("conversation_history.json", self.histories)
+                
+                return response
+                
+        return "I'm getting confused. Let's stop here."
+
+    def generate_reminder_message(self, chat_id, reminder_message):
+        """
+        Called when a scheduled reminder triggers. 
+        Generates a friendly notification message.
+        """
+        prompt = [
+            {"role": "system", "content": "You are Jade. It is time to remind the user of something."},
+            {"role": "user", "content": f"The reminder is: '{reminder_message}'. Write a friendly message to send to the user now."}
+        ]
+        try:
+            completion = self.client.chat.completions.create(
+                messages=prompt,
+                model=self.model,
+                temperature=0.7
+            )
+            return completion.choices[0].message.content
+        except Exception as e:
+            return f"Reminder: {reminder_message}"

hf_storage.py

@@ -0,0 +1,136 @@
+"""
+HuggingFace Datasets Storage Module
+
+Provides persistent storage for Jade bot data using HuggingFace Datasets.
+This allows data to persist across Space restarts.
+"""
+import os
+import json
+import logging
+from typing import Optional, Dict, Any
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+# Try to import huggingface_hub, fallback to local storage if not available
+try:
+    from huggingface_hub import HfApi, hf_hub_download, upload_file
+    HF_AVAILABLE = True
+except ImportError:
+    HF_AVAILABLE = False
+    logger.warning("huggingface_hub not installed. Using local storage only.")
+
+
+class HFStorage:
+    """
+    Storage class that persists data to HuggingFace Hub.
+    Falls back to local JSON files if HF is not configured.
+    """
+    
+    def __init__(self, repo_id: Optional[str] = None, local_dir: str = "jade_data"):
+        """
+        Initialize storage.
+        
+        Args:
+            repo_id: HuggingFace dataset repo ID (e.g., "username/jade-data")
+                     If None, will try to get from HF_STORAGE_REPO env var.
+            local_dir: Local directory for fallback storage
+        """
+        self.repo_id = repo_id or os.getenv("HF_STORAGE_REPO")
+        self.local_dir = local_dir
+        self.token = os.getenv("HF_TOKEN")
+        
+        # Create local dir if needed
+        os.makedirs(self.local_dir, exist_ok=True)
+        
+        # Check if HF storage is properly configured
+        self.use_hf = HF_AVAILABLE and self.repo_id and self.token
+        
+        if self.use_hf:
+            self.api = HfApi(token=self.token)
+            logger.info(f"HF Storage initialized with repo: {self.repo_id}")
+        else:
+            logger.info("Using local storage (HF not configured)")
+    
+    def _local_path(self, filename: str) -> str:
+        """Get local file path for a data file."""
+        return os.path.join(self.local_dir, filename)
+    
+    def load_json(self, filename: str, default: Any = None) -> Any:
+        """
+        Load JSON data from storage.
+        
+        First tries HF Hub, falls back to local file.
+        """
+        if default is None:
+            default = {}
+            
+        # Try HF Hub first
+        if self.use_hf:
+            try:
+                local_file = hf_hub_download(
+                    repo_id=self.repo_id,
+                    filename=filename,
+                    repo_type="dataset",
+                    token=self.token
+                )
+                with open(local_file, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            except Exception as e:
+                logger.debug(f"Could not load {filename} from HF: {e}")
+        
+        # Fallback to local
+        local_path = self._local_path(filename)
+        if os.path.exists(local_path):
+            try:
+                with open(local_path, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            except json.JSONDecodeError:
+                logger.error(f"Error decoding {local_path}")
+        
+        return default
+    
+    def save_json(self, filename: str, data: Any) -> bool:
+        """
+        Save JSON data to storage.
+        
+        Saves locally first, then uploads to HF Hub.
+        """
+        local_path = self._local_path(filename)
+        
+        # Always save locally first
+        try:
+            with open(local_path, 'w', encoding='utf-8') as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
+        except Exception as e:
+            logger.error(f"Error saving {filename} locally: {e}")
+            return False
+        
+        # Upload to HF Hub if configured
+        if self.use_hf:
+            try:
+                upload_file(
+                    path_or_fileobj=local_path,
+                    path_in_repo=filename,
+                    repo_id=self.repo_id,
+                    repo_type="dataset",
+                    token=self.token
+                )
+                logger.debug(f"Uploaded {filename} to HF Hub")
+            except Exception as e:
+                logger.warning(f"Could not upload {filename} to HF: {e}")
+                # Still return True since local save worked
+        
+        return True
+
+
+# Global storage instance
+_storage: Optional[HFStorage] = None
+
+
+def get_storage() -> HFStorage:
+    """Get the global storage instance."""
+    global _storage
+    if _storage is None:
+        _storage = HFStorage()
+    return _storage

main.py

@@ -0,0 +1,114 @@
+import os
+import logging
+import asyncio
+from datetime import datetime
+from telegram import Update
+from telegram.ext import ApplicationBuilder, ContextTypes, CommandHandler, MessageHandler, filters
+
+# Import Agent and ReminderManager
+try:
+    from .core import TelegramJadeAgent
+    from .tools import ReminderManager
+except ImportError:
+    from core import TelegramJadeAgent
+    from tools import ReminderManager
+
+# Logging
+logging.basicConfig(
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    level=logging.INFO
+)
+logger = logging.getLogger(__name__)
+
+# Global instances
+reminder_manager = ReminderManager()
+agent = TelegramJadeAgent(reminder_manager=reminder_manager)
+
+async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    await context.bot.send_message(chat_id=update.effective_chat.id, text="Hi! I'm Jade, your 24h assistant. How can I help you?")
+
+async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    chat_id = update.effective_chat.id
+    user_text = update.message.text
+    
+    # 1. Get response from Agent
+    # agent.chat is blocking (sync), so we wrap it.
+    response = await asyncio.to_thread(agent.chat, chat_id, user_text)
+    
+    await context.bot.send_message(chat_id=chat_id, text=response)
+
+async def send_reminder_job(context: ContextTypes.DEFAULT_TYPE):
+    """Callback function for the scheduled job."""
+    job_data = context.job.data
+    chat_id = job_data["chat_id"]
+    reminder_message = job_data["message"]
+    reminder_id = job_data["id"]
+    
+    # Check if reminder is still valid (not deleted)
+    current_reminders = reminder_manager.get_due_reminders()
+    if not any(r["id"] == reminder_id for r in current_reminders):
+        logger.info(f"Reminder {reminder_id} skipped (deleted or sent).")
+        return
+
+    logger.info(f"Triggering reminder {reminder_id} for chat {chat_id}")
+    
+    # Generate message via Agent
+    text = await asyncio.to_thread(agent.generate_reminder_message, chat_id, reminder_message)
+    
+    await context.bot.send_message(chat_id=chat_id, text=text)
+    
+    # Mark as sent
+    reminder_manager.mark_as_sent(reminder_id)
+
+async def check_reminders_loop(context: ContextTypes.DEFAULT_TYPE):
+    """
+    Background task running every X seconds to check for new reminders in DB
+    and schedule them in the JobQueue.
+    """
+    pending = reminder_manager.get_due_reminders()
+    job_queue = context.job_queue
+    
+    # Get current scheduled jobs by name
+    current_jobs = [j.name for j in job_queue.jobs()]
+    
+    for r in pending:
+        job_name = f"reminder_{r['id']}"
+        if job_name not in current_jobs:
+            try:
+                run_date = datetime.strptime(r["time"], "%Y-%m-%d %H:%M:%S")
+                
+                # If time is in past, schedule for immediate execution
+                if run_date < datetime.now():
+                    run_date = datetime.now()
+                
+                logger.info(f"Scheduling {job_name} for {run_date}")
+                
+                job_queue.run_once(
+                    send_reminder_job, 
+                    when=run_date, 
+                    data=r, 
+                    name=job_name
+                )
+            except Exception as e:
+                logger.error(f"Failed to schedule {job_name}: {e}")
+
+if __name__ == '__main__':
+    token = os.getenv("TELEGRAM_BOT_TOKEN")
+    if not token:
+        print("Error: TELEGRAM_BOT_TOKEN not found.")
+        exit(1)
+        
+    application = ApplicationBuilder().token(token).build()
+    
+    start_handler = CommandHandler('start', start)
+    msg_handler = MessageHandler(filters.TEXT & (~filters.COMMAND), handle_message)
+    
+    application.add_handler(start_handler)
+    application.add_handler(msg_handler)
+    
+    # Add a repeating job to sync reminders (e.g. every 10 seconds)
+    if application.job_queue:
+        application.job_queue.run_repeating(check_reminders_loop, interval=10, first=1)
+    
+    print("Jade Telegram Bot is running...")
+    application.run_polling()

requirements.txt

@@ -0,0 +1,5 @@
+python-telegram-bot[job-queue]
+openai
+duckduckgo-search
+huggingface_hub
+gradio

tools.py

@@ -0,0 +1,106 @@
+import json
+import os
+import logging
+from datetime import datetime
+from duckduckgo_search import DDGS
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+def get_current_datetime() -> str:
+    """Returns the current date and time as a formatted string."""
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+def search_web(query: str) -> str:
+    """Searches the web using DuckDuckGo and returns the top results."""
+    try:
+        with DDGS() as ddgs:
+            results = list(ddgs.text(query, max_results=3))
+        if not results:
+            return "No results found."
+        
+        formatted_results = []
+        for i, res in enumerate(results, 1):
+            formatted_results.append(f"{i}. {res['title']}: {res['body']} (URL: {res['href']})")
+        
+        return "\n".join(formatted_results)
+    except Exception as e:
+        return f"Error searching web: {str(e)}"
+
+class ReminderManager:
+    def __init__(self, storage=None):
+        # Use HFStorage for persistence
+        if storage is None:
+            try:
+                from .hf_storage import get_storage
+            except ImportError:
+                from hf_storage import get_storage
+            storage = get_storage()
+        
+        self.storage = storage
+        self.reminders = []
+        self._load_reminders()
+
+    def _load_reminders(self):
+        self.reminders = self.storage.load_json("reminders.json", default=[])
+
+    def _save_reminders(self):
+        self.storage.save_json("reminders.json", self.reminders)
+
+    def add_reminder(self, chat_id: int, time_str: str, message: str):
+        """
+        Adds a reminder.
+        time_str format: "YYYY-MM-DD HH:MM:SS"
+        """
+        # Generate ID safely
+        if self.reminders:
+            new_id = max(r["id"] for r in self.reminders) + 1
+        else:
+            new_id = 1
+
+        reminder = {
+            "id": new_id,
+            "chat_id": chat_id,
+            "time": time_str,
+            "message": message,
+            "status": "pending"
+        }
+        self.reminders.append(reminder)
+        self._save_reminders()
+        return f"Reminder set for {time_str}: {message}"
+
+    def list_reminders(self, chat_id: int):
+        """Lists pending reminders for a specific chat."""
+        user_reminders = [r for r in self.reminders if r["chat_id"] == chat_id and r["status"] == "pending"]
+        if not user_reminders:
+            return "No pending reminders."
+        
+        result = "Pending Reminders:\n"
+        for r in user_reminders:
+            result += f"- [{r['time']}] {r['message']} (ID: {r['id']})\n"
+        return result
+
+    def delete_reminder(self, chat_id: int, reminder_id: int):
+        """Deletes a reminder by ID."""
+        for i, r in enumerate(self.reminders):
+            if r["id"] == reminder_id and r["chat_id"] == chat_id:
+                del self.reminders[i]
+                self._save_reminders()
+                return f"Reminder ID {reminder_id} deleted."
+        return f"Reminder ID {reminder_id} not found."
+
+    def get_due_reminders(self):
+        """
+        Returns a list of reminders that are due now or in the past and mark them as sent?
+        Actually, the scheduler will likely handle the trigger logic, but we need a way to
+        retrieve 'active' reminders to schedule them on startup.
+        """
+        return [r for r in self.reminders if r["status"] == "pending"]
+    
+    def mark_as_sent(self, reminder_id: int):
+        for r in self.reminders:
+            if r["id"] == reminder_id:
+                r["status"] = "sent"
+                self._save_reminders()
+                return