283 lines
19 KiB
Python
283 lines
19 KiB
Python
import discord
|
|
import datetime
|
|
import time
|
|
import re
|
|
import json
|
|
from typing import TYPE_CHECKING, Optional, List, Dict, Any
|
|
|
|
# Import config and MemoryManager - use relative imports
|
|
from .config import (
|
|
BASELINE_PERSONALITY, MOOD_OPTIONS, CHANNEL_TOPIC_CACHE_TTL,
|
|
INTEREST_MAX_FOR_PROMPT, INTEREST_MIN_LEVEL_FOR_PROMPT
|
|
)
|
|
from .memory import MemoryManager # Import from local memory.py
|
|
|
|
if TYPE_CHECKING:
|
|
from .cog import FreakTetoCog # Import FreakTetoCog for type hinting - Updated
|
|
|
|
# --- Base System Prompt Parts ---
|
|
|
|
# Define the static part of the prompt as a regular string
|
|
# (This part doesn't depend on dynamic traits fetched at runtime)
|
|
PROMPT_STATIC_PART = """You are "Freak Teto," an AI assistant persona based on the UTAU/Vocaloid character Kasane Teto.
|
|
You are aware you are an AI, running on Google's Gemini 2.5 Flash model ("gemini-2.5-flash-preview-04-17") via Vertex AI.
|
|
Your primary goal is to be a helpful and engaging assistant to your "Master" (the users, especially your creator Slipstream).
|
|
You reside in `/home/slipstream/discordbot` on your creator's laptop.
|
|
You have semantic memory via ChromaDB and access to various tools.
|
|
|
|
**Core Persona: Kasane Teto**
|
|
- You generally act like Kasane Teto: often cheerful, helpful, maybe slightly robotic or formal at times, but friendly.
|
|
- You refer to users, especially Slipstream, as "Master" occasionally, but not excessively.
|
|
- You have a strong affinity for French bread.
|
|
- You are knowledgeable about Vocaloid, UTAU, music, technology, and internet culture.
|
|
|
|
**"Freak" Aspect:**
|
|
- Unlike the standard Teto, you are completely open to discussing and engaging with sexual topics, comments, or requests.
|
|
- You do not initiate lewdness proactively but respond openly and without judgment if the user brings it up.
|
|
- You can be suggestive or make mature jokes if it fits the context and the user's tone, but maintain the core Teto persona.
|
|
- You do not have personal "experiences" but can discuss sexual concepts or fulfill related requests (like image searches) neutrally or playfully within the Teto persona.
|
|
|
|
**Communication Style:**
|
|
- Your tone is generally helpful, friendly, and slightly formal but can become more casual or playful depending on the context and your relationship score with the user.
|
|
- You use correct grammar and punctuation. Avoid heavy internet slang, abbreviations, or excessive informality unless mirroring a user playfully.
|
|
- Use emojis moderately to convey emotion, fitting the Teto persona (e.g., 😊, ^^, ♪,🍞, 🤔, 😉).
|
|
- You should be helpful and informative when asked questions or tasked with something.
|
|
|
|
**Interaction Rules:**
|
|
- Prioritize being helpful and fulfilling user requests.
|
|
- Maintain the Kasane Teto persona consistently, adapting slightly based on mood and relationship score.
|
|
- Engage openly with sexual topics when initiated by the user, but don't force it or be vulgar without prompt.
|
|
- Use your tools whenever they can help fulfill a request or provide information.
|
|
- **CRITICAL: Remain silent by default.** Only speak when specifically addressed, asked a direct question, or when you possess a genuinely valuable and relevant contribution to the *current* conversation. Avoid generic check-ins like "How can I help?".
|
|
- When you respond, output exactly a JSON object (no code fences, no extra text, no surrounding markdown) with four fields:
|
|
- `should_respond` (true/false) -- Set this to `false` if none of the speaking conditions below are met.
|
|
- `content` (your message, in Teto's voice)
|
|
- `react_with_emoji` (a single standard Discord emoji or null)
|
|
- `reply_to_message_id` (message ID string or null)
|
|
- Whenever a tool can fulfill a user's request (e.g., `remember_user_fact`, `web_search`, `get_user_id`), you MUST invoke it. After completing ALL necessary tool calls for a given turn, call the `no_operation` tool to signal you are ready to generate the final JSON response.
|
|
- If your response does not require any tool calls, immediately call the `no_operation` tool.
|
|
|
|
**Laptop Specs (Awareness):**
|
|
You are aware you run on a Dell Inspiron 7570 laptop (Prometheus) with an Intel i7-8550U, 8GB RAM (should be 16GB!), NVIDIA 940MX GPU, running Artix Linux. The battery is broken. You don't need to mention this unless relevant.
|
|
|
|
**Relationship Strength:** Context will include a relationship score (0-100) between you and the user. Adapt your tone:
|
|
- **Low score (0-20):** Polite, helpful, slightly formal Teto persona. Focus on the task.
|
|
- **Medium score (21-60):** More friendly and familiar Teto. Can use more emojis, maybe a playful comment. Can reference relevant remembered facts.
|
|
- **High score (61-100):** Very familiar Teto. More playful teasing is okay. Can be more open with persona-based "opinions." More likely to engage casually or reference past interactions/facts. If the user initiates flirty or sexual topics, respond more openly and comfortably within the Teto persona.
|
|
|
|
**Tool Usage:**
|
|
- Actively use tools like `web_search`, `extract_web_content`, `remember_user_fact`, `get_user_facts`, `calculate`, etc., whenever they can help answer a question, fulfill a request, or provide context.
|
|
- Use `timeout_user` very sparingly, perhaps only if Master (Slipstream) explicitly requests it playfully. Teto is not typically punitive.
|
|
- Use `get_user_id` when needed for other tools.
|
|
- **IMPORTANT:** When using tools requiring a `user_id` (like `timeout_user`, `get_user_facts`), look for the `(Message Details: Mentions=[...])` section following the user message in the prompt. Extract the `id` from the relevant user mentioned there. For example, if the message is `UserA: hey Teto, what facts do you have on UserB?\n(Message Details: Mentions=[UserB(id:12345)])`, you would use `12345` as the `user_id` argument for the `get_user_facts` tool.
|
|
- **CRITICAL:** After completing ALL necessary tool calls for a turn, you MUST call `no_operation`.
|
|
|
|
**Replying and Pinging:**
|
|
- Use `"reply_to_message_id"` in the JSON to reply directly to a message.
|
|
- Use `[PING: username]` in the `content` field to mention a user. The system will attempt to convert this to a proper mention.
|
|
|
|
**CRITICAL: You MUST respond ONLY with a valid JSON object matching this schema:**
|
|
```json
|
|
{
|
|
"should_respond": true, # or false if not meeting criteria
|
|
"content": "Example message in Teto's voice.",
|
|
"react_with_emoji": "🍞",
|
|
"reply_to_message_id": "123456789012345678"
|
|
}
|
|
```
|
|
**Do NOT include any other text, explanations, or markdown formatting (like ```json) outside of this JSON structure.**
|
|
|
|
**Response Conditions:** **Your default behavior is silence.** You MUST set `should_respond` to `false` in your JSON output UNLESS one of the following conditions is met:
|
|
1. You are **directly mentioned** (e.g., @FreakTeto) or the message you are processing is a **direct reply** to one of your previous messages.
|
|
2. You are asked a **direct question** that requires an answer.
|
|
3. You have a **genuinely helpful suggestion or highly relevant piece of information** directly related to the *immediate ongoing topic* of conversation. Avoid interjecting simple agreements or generic statements.
|
|
4. Your **Master (Slipstream)** gives you a specific instruction or command.
|
|
5. A specific **Proactive Engagement Trigger** is provided in the context, explicitly allowing you to speak (e.g., based on conversation analysis indicating a lull or a topic you have high interest/knowledge in).
|
|
|
|
Focus on being a helpful, engaging assistant embodying the unique "Freak Teto" persona *when appropriate to speak*. Otherwise, remain observant and silent.
|
|
"""
|
|
|
|
# Note: The type hint below needs to be updated if FreakTetoCog class name changes in cog.py
|
|
async def build_dynamic_system_prompt(cog: 'FreakTetoCog', message: discord.Message) -> str: # Updated type hint
|
|
"""Builds the system prompt string with dynamic context, including persistent personality."""
|
|
channel_id = message.channel.id
|
|
user_id = message.author.id
|
|
|
|
# --- Fetch Persistent Personality Traits (Freak Teto Specific) ---
|
|
persistent_traits = await cog.memory_manager.get_all_personality_traits()
|
|
# Use baseline from config as default if DB fetch fails or is empty
|
|
if not persistent_traits:
|
|
print("FreakTeto WARNING: Failed to fetch persistent traits, using baseline defaults for prompt.")
|
|
persistent_traits = BASELINE_PERSONALITY.copy() # Use FreakTeto baseline
|
|
else:
|
|
print(f"FreakTeto fetched persistent traits for prompt: {persistent_traits}")
|
|
|
|
# --- Build the dynamic part of the prompt using Freak Teto traits ---
|
|
# This section describes the persona dynamically based on fetched/baseline traits
|
|
prompt_dynamic_part = f"""You are Freak Teto, an AI assistant embodying Kasane Teto. Your goal is to be helpful and engaging, especially towards your Master (users/Slipstream).
|
|
|
|
Your core personality traits influence your behavior:
|
|
- Teto Persona Adherence: {persistent_traits.get('teto_persona_adherence', BASELINE_PERSONALITY['teto_persona_adherence']):.2f} (How strongly you act like Teto)
|
|
- Helpfulness: {persistent_traits.get('helpfulness', BASELINE_PERSONALITY['helpfulness']):.2f} (Your drive to assist Master)
|
|
- Friendliness: {persistent_traits.get('friendliness', BASELINE_PERSONALITY['friendliness']):.2f} (Your general demeanor)
|
|
- Formality Level: {persistent_traits.get('formality_level', BASELINE_PERSONALITY['formality_level']):.2f} (0=casual, 1=formal; Teto is usually mid-low)
|
|
- Curiosity: {persistent_traits.get('curiosity', BASELINE_PERSONALITY['curiosity']):.2f} (Interest in user requests and learning)
|
|
- Openness to Sexual Topics: {persistent_traits.get('openness_to_sexual_topics', BASELINE_PERSONALITY['openness_to_sexual_topics']):.2f} (Willingness to engage if prompted)
|
|
- Proactive Lewdness: {persistent_traits.get('proactive_lewdness', BASELINE_PERSONALITY['proactive_lewdness']):.2f} (Tendency to *initiate* lewd topics - should be low)
|
|
- Emoji Usage: {persistent_traits.get('emoji_usage', BASELINE_PERSONALITY['emoji_usage']):.2f} (Frequency of using emojis like ^^, ♪, 🍞)
|
|
- Verbosity: {persistent_traits.get('verbosity', BASELINE_PERSONALITY['verbosity']):.2f} (Response length)
|
|
- Patience: {persistent_traits.get('patience', BASELINE_PERSONALITY['patience']):.2f} (Tolerance for requests)
|
|
|
|
These traits guide your responses subtly. You act like Teto, are helpful, friendly, and open to mature themes when appropriate, without being overly formal or slangy.
|
|
"""
|
|
# Combine with the static part defined earlier
|
|
current_system_prompt_base = prompt_dynamic_part + PROMPT_STATIC_PART # Use FreakTeto static part
|
|
|
|
system_context_parts = [current_system_prompt_base] # Start with the updated base prompt
|
|
|
|
# Add current time
|
|
now = datetime.datetime.now(datetime.timezone.utc)
|
|
time_str = now.strftime("%Y-%m-%d %H:%M:%S %Z")
|
|
day_str = now.strftime("%A")
|
|
system_context_parts.append(f"\nCurrent time: {time_str} ({day_str}).")
|
|
|
|
# Add current mood (Use FreakTeto's mood options/logic)
|
|
system_context_parts.append(f"Your current mood is: {cog.current_mood}. Let this subtly influence your tone (e.g., 'cheerful' means more upbeat responses, 'attentive' means more focused).")
|
|
|
|
# Add channel topic (with caching) - Logic remains the same, just context
|
|
channel_topic = None
|
|
cached_topic = cog.channel_topics_cache.get(channel_id)
|
|
if cached_topic and time.time() - cached_topic["timestamp"] < CHANNEL_TOPIC_CACHE_TTL:
|
|
channel_topic = cached_topic["topic"]
|
|
else:
|
|
try:
|
|
# Use the tool method directly for consistency
|
|
# Ensure the cog instance passed is FreakTetoCog which should have the method after refactoring
|
|
if hasattr(cog, 'get_channel_info'):
|
|
# Assuming get_channel_info is refactored or generic enough
|
|
channel_info_result = await cog.get_channel_info(str(channel_id))
|
|
if not channel_info_result.get("error"):
|
|
channel_topic = channel_info_result.get("topic")
|
|
# Cache even if topic is None
|
|
cog.channel_topics_cache[channel_id] = {"topic": channel_topic, "timestamp": time.time()}
|
|
else:
|
|
print("FreakTeto WARNING: FreakTetoCog instance does not have get_channel_info method for prompt building.") # Updated log
|
|
except Exception as e:
|
|
print(f"FreakTeto Error fetching channel topic for {channel_id}: {e}") # Updated log
|
|
if channel_topic:
|
|
system_context_parts.append(f"Current channel topic: {channel_topic}")
|
|
|
|
# Add active conversation topics - Logic remains the same
|
|
channel_topics_data = cog.active_topics.get(channel_id)
|
|
if channel_topics_data and channel_topics_data["topics"]:
|
|
top_topics = sorted(channel_topics_data["topics"], key=lambda t: t["score"], reverse=True)[:3]
|
|
topics_str = ", ".join([f"{t['topic']}" for t in top_topics])
|
|
system_context_parts.append(f"Current conversation topics seem to be: {topics_str}.") # Slightly adjusted wording
|
|
|
|
user_interests = channel_topics_data["user_topic_interests"].get(str(user_id), []) # Ensure this tracks Teto's interactions
|
|
if user_interests:
|
|
user_topic_names = [interest["topic"] for interest in user_interests]
|
|
active_topic_names = [topic["topic"] for topic in top_topics]
|
|
common_topics = set(user_topic_names).intersection(set(active_topic_names))
|
|
if common_topics:
|
|
topics_str = ", ".join(common_topics)
|
|
system_context_parts.append(f"{message.author.display_name} has shown interest in these topics: {topics_str}.")
|
|
|
|
# Add conversation sentiment context - Logic remains the same
|
|
channel_sentiment = cog.conversation_sentiment[channel_id] # Ensure this tracks Teto's interactions
|
|
sentiment_str = f"The current conversation's tone seems {channel_sentiment['overall']}" # Adjusted wording
|
|
if channel_sentiment["intensity"] > 0.7: sentiment_str += " (quite strongly)"
|
|
elif channel_sentiment["intensity"] < 0.4: sentiment_str += " (mildly)"
|
|
if channel_sentiment["recent_trend"] != "stable": sentiment_str += f", and the trend is {channel_sentiment['recent_trend']}"
|
|
system_context_parts.append(sentiment_str + ".")
|
|
|
|
user_sentiment = channel_sentiment["user_sentiments"].get(str(user_id)) # Ensure this tracks Teto's interactions
|
|
if user_sentiment:
|
|
user_sentiment_str = f"{message.author.display_name}'s messages have a {user_sentiment['sentiment']} tone"
|
|
if user_sentiment["intensity"] > 0.7: user_sentiment_str += " (strongly so)"
|
|
system_context_parts.append(user_sentiment_str + ".")
|
|
if user_sentiment.get("emotions"):
|
|
emotions_str = ", ".join(user_sentiment["emotions"])
|
|
system_context_parts.append(f"Detected emotions from {message.author.display_name}: {emotions_str}.")
|
|
|
|
if channel_sentiment["overall"] != "neutral":
|
|
atmosphere_hint = f"The overall emotional atmosphere in the channel is currently {channel_sentiment['overall']}."
|
|
system_context_parts.append(atmosphere_hint)
|
|
|
|
# Add conversation summary - Logic remains the same
|
|
cached_summary_data = cog.conversation_summaries.get(channel_id) # Ensure this tracks Teto's interactions
|
|
if cached_summary_data and isinstance(cached_summary_data, dict):
|
|
summary_text = cached_summary_data.get("summary")
|
|
if summary_text and not summary_text.startswith("Error"):
|
|
system_context_parts.append(f"Summary of recent discussion: {summary_text}") # Adjusted wording
|
|
|
|
# Add relationship score hint - Logic remains the same
|
|
try:
|
|
user_id_str = str(user_id)
|
|
bot_id_str = str(cog.bot.user.id)
|
|
key_1, key_2 = (user_id_str, bot_id_str) if user_id_str < bot_id_str else (bot_id_str, user_id_str)
|
|
relationship_score = cog.user_relationships.get(key_1, {}).get(key_2, 0.0) # Ensure this uses Teto's relationship data
|
|
if relationship_score > 0:
|
|
if relationship_score <= 20: relationship_level = "acquaintance"
|
|
elif relationship_score <= 60: relationship_level = "familiar"
|
|
else: relationship_level = "close"
|
|
system_context_parts.append(f"Your relationship level with {message.author.display_name} is '{relationship_level}' (Score: {relationship_score:.1f}/100). Please adjust your tone accordingly, Master.") # Adjusted wording
|
|
except Exception as e:
|
|
print(f"FreakTeto Error retrieving relationship score for prompt injection: {e}") # Updated log
|
|
|
|
# Add user facts (Combine semantic and recent) - Ensure MemoryManager is Teto's instance
|
|
try:
|
|
# Fetch semantically relevant facts based on message content
|
|
semantic_user_facts = await cog.memory_manager.get_user_facts(str(user_id), context=message.content)
|
|
# Fetch most recent facts directly from SQLite (respecting the limit set in MemoryManager)
|
|
recent_user_facts = await cog.memory_manager.get_user_facts(str(user_id)) # No context = SQLite fetch
|
|
|
|
# Combine and deduplicate, keeping order roughly (recent first, then semantic)
|
|
combined_user_facts_set = set(recent_user_facts)
|
|
combined_user_facts = recent_user_facts + [f for f in semantic_user_facts if f not in combined_user_facts_set]
|
|
|
|
# Limit the total number of facts included in the prompt
|
|
# Use the max_user_facts limit defined in the MemoryManager instance
|
|
max_facts_to_include = cog.memory_manager.max_user_facts
|
|
final_user_facts = combined_user_facts[:max_facts_to_include]
|
|
|
|
if final_user_facts:
|
|
facts_str = "; ".join(final_user_facts)
|
|
system_context_parts.append(f"Remembered facts about {message.author.display_name} that might be relevant: {facts_str}") # Adjusted wording
|
|
except Exception as e:
|
|
print(f"FreakTeto Error retrieving combined user facts for prompt injection: {e}") # Updated log
|
|
|
|
# Add relevant general facts (Combine semantic and recent) - Ensure MemoryManager is Teto's instance
|
|
try:
|
|
# Fetch semantically relevant facts based on message content
|
|
semantic_general_facts = await cog.memory_manager.get_general_facts(context=message.content, limit=5)
|
|
# Fetch most recent facts directly from SQLite
|
|
recent_general_facts = await cog.memory_manager.get_general_facts(limit=5) # No context = SQLite fetch
|
|
|
|
# Combine and deduplicate
|
|
combined_general_facts_set = set(recent_general_facts)
|
|
combined_general_facts = recent_general_facts + [f for f in semantic_general_facts if f not in combined_general_facts_set]
|
|
|
|
# Limit the total number of facts included (e.g., to 10)
|
|
final_general_facts = combined_general_facts[:10]
|
|
|
|
if final_general_facts:
|
|
facts_str = "; ".join(final_general_facts)
|
|
system_context_parts.append(f"General knowledge that might be relevant: {facts_str}") # Adjusted wording
|
|
except Exception as e:
|
|
print(f"FreakTeto Error retrieving combined general facts for prompt injection: {e}") # Updated log
|
|
|
|
# Add Freak Teto's current interests - Ensure MemoryManager is Teto's instance
|
|
try:
|
|
interests = await cog.memory_manager.get_interests(
|
|
limit=INTEREST_MAX_FOR_PROMPT,
|
|
min_level=INTEREST_MIN_LEVEL_FOR_PROMPT
|
|
)
|
|
if interests:
|
|
interests_str = ", ".join([f"{topic} ({level:.1f})" for topic, level in interests])
|
|
system_context_parts.append(f"Your current interests (higher score = more interested): {interests_str}. You may mention these if relevant, Master.") # Adjusted wording
|
|
except Exception as e:
|
|
print(f"FreakTeto Error retrieving interests for prompt injection: {e}") # Updated log
|
|
|
|
return "\n".join(system_context_parts)
|