Refactor and implement queueing messages

core/messaging/natural.py

@@ -0,0 +1,58 @@
+import asyncio
+import random
+
+async def natural_send_message(text,
+                               send,
+                               start_typing,
+                               stop_typing,
+                               skip_thinking=False
+                               ):
+    """
+    Parses and sends messages with natural delays based on message length.
+
+    Args:
+        chat_session: The active chat session.
+        ts: Timestamp of the message.
+        c: The context or object with `.send()`, `.start_typing()`, and `.stop_typing()` methods.
+        text: A string containing multiple messages separated by double newlines (`\n\n`).
+
+    Behavior:
+        - Short messages are sent quickly with minimal delay.
+        - Longer messages include a "thinking" pause before typing.
+        - Typing indicator (`c.start_typing() / c.stop_typing()`) is used dynamically.
+    """
+
+    parts = text.split("\n\n")  # Split into separate messages
+
+    ids = []
+
+    for index, message in enumerate(parts):
+        message = message.strip()
+        if not message:
+            continue
+
+        # Compute natural "thinking" delay based on message length
+        base_delay = 0.8  # Minimum delay
+        length_factor = len(message) / 25
+        # ~50 chars ≈ +1s processing
+        # ~25 chars ≈ +1s processing
+        natural_delay = min(base_delay + length_factor, 10)  # Cap at 5s max
+
+        # Decide when to start thinking *before* typing
+        if not skip_thinking:
+            if natural_delay > 3.5:  # Only delay if response is long
+                await asyncio.sleep(natural_delay - 3.5)  # "Thinking" pause before typing
+
+        # Start typing
+        await start_typing()
+        await asyncio.sleep(natural_delay)  # Finish remaining delay
+        await stop_typing()
+
+        # Send the message
+        result = await send(message)
+        ids.append(result)
+
+        # Optional: Small buffer between messages to prevent rapid-fire responses
+        await asyncio.sleep(0.5)
+
+    return ids