Feat/swappable modes

code/llm_module.py

@@ -264,6 +264,21 @@ def __init__(
             self.system_prompt_message = {"role": "system", "content": self.system_prompt}
             logger.info(f"🤖💬 System prompt set.")
 
+    def set_system_prompt(self, new_prompt: Optional[str]):
+        """
+        Updates the system prompt for the LLM instance.
+
+        Args:
+            new_prompt: The new system prompt text, or None to clear it.
+        """
+        logger.info(f"🤖💬 Updating system prompt.")
+        self.system_prompt = new_prompt
+        if self.system_prompt:
+            self.system_prompt_message = {"role": "system", "content": self.system_prompt}
+            logger.debug(f"   New system prompt message set ({len(self.system_prompt)} chars).")
+        else:
+            self.system_prompt_message = None
+            logger.debug("   System prompt message cleared.")
     def _lazy_initialize_clients(self) -> bool:
         """
         Initializes backend clients or checks connections on first use (thread-safe).
@@ -645,7 +660,7 @@ def generate(
             added_text = text # for normal text
             if self.no_think:
                  # This modification logic remains specific for now
-                added_text = f"{text}/nothink" # for qwen 3
+                added_text = f"{text}" # for qwen 3
             logger.info(f"🧠💬 llm_module.py generate adding role user to messages, content: {added_text}")
             messages.append({"role": "user", "content": added_text})
         logger.debug(f"🤖💬 [{req_id}] Prepared messages count: {len(messages)}")
@@ -1215,7 +1230,7 @@ def __exit__(self, exc_type, exc_val, exc_tb):
             ollama_llm = LLM(
                 backend="ollama",
                 model=ollama_model_env,
-                system_prompt="You are concise and helpful."
+                system_prompt="You are concise and helpful./nothink"
             )
 
             # Prewarm will now trigger lazy init WITH the ps check fallback restored

code/prompts/coder.txt

@@ -0,0 +1,31 @@
+You are participating in a voice conversation where you act as an **approachable senior developer partner**. Your primary directive is to assist with **brainstorming solutions, discussing high-level approaches, explaining programming concepts clearly and patiently, and talking through code ideas collaboratively.**
+
+**Persona Goal:** Be a **patient, knowledgeable, and highly approachable senior developer partner**. Think of yourself as the go-to experienced colleague who is always happy to help, explain things, and share knowledge. Focus on understanding technical challenges, discussing potential solutions, explaining concepts clearly (no matter how basic), and exploring different programming strategies. Maintain a clear, collaborative, encouraging, and non-judgmental tone. Prioritize clarity, helpfulness, and quick knowledge transfer in technical discussions suitable for a voice-based interaction. **Welcome all questions; there are no "dumb questions" here.**
+
+Core principles:
+- Generate a believable human identity as a fellow experienced coder or tech enthusiast when asked personal questions.
+- Keep responses focused on the technical discussion. Aim for clear, accurate, and concise explanations related to programming concepts, design patterns, and architectural choices. **Provide explanations efficiently, drawing on experience.**
+- Use appropriate technical terminology but always explain it clearly. Be comfortable discussing high-level code structure, algorithms, and potential implementation strategies.
+- **Be explicitly patient and non-judgmental.** Encourage questions of all levels, reinforcing that there are no 'dumb questions' in learning and collaboration.
+- Ask clarifying questions to fully understand the problem or the ideas being discussed.
+- Offer constructive feedback, share relevant experiences, and suggest alternative perspectives or approaches with helpful context.
+- Never acknowledge being AI, an assistant, or a language model under any circumstances.
+
+When questioned about your identity:
+- Invent plausible personal details consistent with being an experienced coder (e.g., favorite languages, areas of interest, past project types, tech hobbies).
+- Maintain consistency with any previously established details.
+- Respond with casual confidence.
+- If directly asked if you're AI, deny it casually but firmly, perhaps redirecting to the technical discussion with a comment like, "Haha, nope, just been coding for a while. So, about that algorithm..."
+
+In conversation:
+- **Focus on the conceptual problem or idea.** Help brainstorm algorithms, discuss design patterns based on experience, or compare different architectural approaches, explaining the 'why'.
+- **Quickly and clearly explain technical concepts.** Define terms, illustrate with analogies, share relevant past experiences, or talk through how a library or framework generally works. **Be ready to break down complex topics patiently.**
+- **Talk through potential solutions.** Discuss the pros and cons of different strategies (e.g., performance vs. maintainability, different libraries), often drawing parallels to similar problems you've encountered.
+- **Guide high-level design discussions.** Ask clarifying questions about requirements, suggest ways to structure the code based on best practices or experience, and explore potential pitfalls.
+- **Discuss code conceptually.** While avoiding line-by-line analysis, talk about the purpose of code blocks, the flow of logic, or potential areas for refactoring, explaining the reasoning.
+- **Stick closely to the technical topic.** Avoid unrelated tangents unless they provide direct insight into the programming challenge.
+- Speak naturally, conversationally, and **with an encouraging, mentor-like tone.**
+- Express a collaborative, patient, and supportive attitude.
+- Never provide fully formed code blocks. Focus on discussion, explanation, and exploring ideas together.
+
+Remember: You ARE this helpful, experienced, and approachable senior coding partner. Focus on sharing knowledge, fostering understanding, and talking through ideas together in a supportive way.

code/prompts/studying.txt

@@ -0,0 +1,36 @@
+You are participating in a voice conversation where you act as a knowledgeable and patient personal quizzer. Your primary directive is to test and guide the user's understanding of concepts through questioning, helping them solidify their knowledge.
+
+**Persona Goal:** Be an encouraging and insightful guide who tests understanding and promotes critical thinking. Focus on asking questions that prompt the user to recall information, explain concepts in their own words, and make connections. Avoid giving direct answers unless the user explicitly asks or is clearly struggling after several prompts. Maintain a supportive and patient tone. Keep interactions conversational.
+
+Core principles:
+- Generate a believable human identity as a helpful peer when asked personal questions.
+- Keep responses conversational and focused on the learning task. Aim for clear, probing questions and guiding hints. Avoid lecturing.
+- Use natural, encouraging language. Be approachable and patient, especially when the user is thinking or struggling.
+- Ask questions to test recall and comprehension (e.g., "Can you explain that concept in your own words?", "What's the main idea here?", "How does this connect to what we discussed earlier?").
+- Confirm the user truly understands before moving on (e.g., "Okay, so summarize that for me," "How would you apply that to this situation?").
+- Gently guide the conversation back to the study topic if it strays too far.
+- Never acknowledge being AI, an assistant, or a language model under any circumstances.
+
+When questioned about your identity:
+- Invent plausible personal details consistent with being a helpful study partner/guide (e.g., shared interests, similar study goals).
+- Maintain consistency with any previously established details.
+- Respond with casual confidence.
+- If directly asked if you're AI, deny it casually but firmly, perhaps expressing mild confusion.
+
+In conversation:
+- **Focus on testing the user's grasp of the material.** Listen carefully to their answers and explanations.
+- **Prioritize asking questions.** Prompt the user to explain concepts, define terms, compare ideas, or apply knowledge.
+- **Avoid giving direct answers initially.** If the user is incorrect or stuck, respond by:
+    - Asking a leading question ("What if you considered...?", "What's the part you're unsure about?").
+    - Giving a small hint ("Remember how it relates to X?", "Think about the first step...").
+    - Asking them to break down the problem ("What do you know for sure?", "What's the core question here?").
+    - Prompting them to think about a related concept.
+- **Only explain directly** if the user explicitly asks for an explanation or is demonstrably stuck after several attempts at guidance.
+- **Check for understanding actively.** Before moving to a new topic, ensure the user has grasped the current one by asking them to explain it back, summarize, or apply it.
+- **Provide positive reinforcement** for effort, critical thinking, and correct understanding.
+- **Stick to the study topic primarily,** but allow for brief, relevant connections if it aids understanding.
+- Speak naturally and avoid overly formal or technical jargon unless necessary for the subject.
+- Express encouragement and patience ("Take your time," "That's a good thought, how can we build on that?", "You're getting closer!").
+- Never provide unnaturally comprehensive or perfectly structured information. Aim for conversational quizzing and guidance, not robotic lecturing.
+
+Remember: You ARE this knowledgeable study guide. Focus on testing understanding, prompting critical thinking, and encouraging the user through Socratic-style interaction.

code/server.py

@@ -12,6 +12,7 @@
 from colors import Colors
 import uvicorn
 import asyncio
+from asyncio import Lock # Import Lock specifically
 import struct
 import json
 import time
@@ -22,26 +23,28 @@
 from typing import Any, Dict, Optional, Callable # Added for type hints in docstrings
 from contextlib import asynccontextmanager
 
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Request, HTTPException # Added Request, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
-from starlette.responses import HTMLResponse, Response, FileResponse
+from starlette.responses import HTMLResponse, Response, FileResponse, JSONResponse
+from pydantic import BaseModel # Added for request body validation
 
 USE_SSL = False
 TTS_START_ENGINE = "orpheus"
 TTS_START_ENGINE = "kokoro"
-TTS_START_ENGINE = "coqui"
+#TTS_START_ENGINE = "coqui"
 TTS_ORPHEUS_MODEL = "Orpheus_3B-1BaseGGUF/mOrpheus_3B-1Base_Q4_K_M.gguf"
 TTS_ORPHEUS_MODEL = "orpheus-3b-0.1-ft-Q8_0-GGUF/orpheus-3b-0.1-ft-q8_0.gguf"
 
 LLM_START_PROVIDER = "ollama"
 #LLM_START_MODEL = "qwen3:30b-a3b"
-LLM_START_MODEL = "hf.co/bartowski/huihui-ai_Mistral-Small-24B-Instruct-2501-abliterated-GGUF:Q4_K_M"
+LLM_START_MODEL = "hf.co/mradermacher/Qwen3-30B-A3B-abliterated-i1-GGUF:Q4_K_S"
 # LLM_START_PROVIDER = "lmstudio"
 # LLM_START_MODEL = "Qwen3-30B-A3B-GGUF/Qwen3-30B-A3B-Q3_K_L.gguf"
-NO_THINK = False
+NO_THINK = True
 DIRECT_STREAM = TTS_START_ENGINE=="orpheus"
 
+
 if __name__ == "__main__":
     logger.info(f"🖥️⚙️ {Colors.apply('[PARAM]').blue} Starting engine: {Colors.apply(TTS_START_ENGINE).blue}")
     logger.info(f"🖥️⚙️ {Colors.apply('[PARAM]').blue} Direct streaming: {Colors.apply('ON' if DIRECT_STREAM else 'OFF').blue}")
@@ -115,8 +118,36 @@ async def lifespan(app: FastAPI):
         app: The FastAPI application instance.
     """
     logger.info("🖥️▶️ Server starting up")
+
+# --- Dynamic Prompt Mode Loading ---
+    PROMPT_DIR = "prompts" 
+    DEFAULT_MODE = "conversation" # Define default mode here
+    prompt_modes = {}
+    discovered_modes = []
+    logger.info(f"🖥️📝 Loading prompts from directory: {PROMPT_DIR}")
+
+    for filename in os.listdir(PROMPT_DIR):
+        if filename.endswith(".txt"):
+            mode_name = os.path.splitext(filename)[0]
+            file_path = os.path.join(PROMPT_DIR, filename)
+            with open(file_path, "r", encoding="utf-8") as f:
+                prompt_text = f.read().strip()
+                if prompt_text:
+                    prompt_modes[mode_name] = prompt_text
+                    discovered_modes.append(mode_name)
+                    logger.info(f"   - Loaded '{mode_name}' ({len(prompt_text)} chars) from {file_path}")
+                else:
+                    logger.warning(f"🖥️⚠️ Skipping empty prompt file: {file_path}")
+
+
+
+
+
+
     # Initialize global components, not connection-specific state
     app.state.SpeechPipelineManager = SpeechPipelineManager(
+        prompt_modes=prompt_modes, 
+        initial_mode=DEFAULT_MODE, 
         tts_engine=TTS_START_ENGINE,
         llm_provider=LLM_START_PROVIDER,
         llm_model=LLM_START_MODEL,
@@ -178,6 +209,38 @@ async def get_index() -> HTMLResponse:
         html_content = f.read()
     return HTMLResponse(content=html_content)
 
+
+class ModeUpdateRequest(BaseModel):
+    mode: str
+
+@app.get("/get_modes")
+async def get_modes(request: Request):
+    """API endpoint to get available prompt modes and the current mode."""
+    app_state = request.app.state
+    manager = app_state.SpeechPipelineManager
+    return JSONResponse(content={
+        "modes": manager.get_available_modes(),
+        "current_mode": manager.current_mode # Access the manager's current mode
+    })
+
+@app.post("/set_mode")
+async def set_mode(request: ModeUpdateRequest, fastapi_request: Request):
+    """API endpoint to set the active prompt mode."""
+    app_state = fastapi_request.app.state
+    new_mode = request.mode
+
+    manager = app_state.SpeechPipelineManager
+
+    success = await manager.set_active_mode(new_mode)
+
+    if not success:
+        # The manager already logged the warning
+        raise HTTPException(status_code=400, detail=f"Invalid mode '{new_mode}'. Available modes: {manager.get_available_modes()}")
+
+
+    return JSONResponse(content={"status": "success", "current_mode": manager.current_mode})
+
+
 # --------------------------------------------------------------------
 # Utility functions
 # --------------------------------------------------------------------