first-features

.gitignore

@@ -0,0 +1,32 @@
+# Byte-compiled / cache
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# Packaging / build
+*.egg-info/
+dist/
+build/
+
+# OS/editor
+.DS_Store
+.idea/
+.vscode/
+
+# Local env/config
+.env
+.env.*
+
+.claude/
+.codex/
+
+CLAUDE.md
+AGENTS.md
+
+.*_cache/

.python-version

@@ -0,0 +1 @@
+3.10.11

README.md

@@ -1,12 +1,120 @@
 ---
-title: Reframe
-emoji: 🏢
-colorFrom: red
+title: Reframe Cognitive Reframing Assistant
+emoji: 🧠
+colorFrom: blue
 colorTo: purple
 sdk: gradio
 sdk_version: 5.47.2
+python_version: 3.10
 app_file: app.py
 pinned: false
+license: mit
+hf_oauth: true
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🧠 reframe: Cognitive Reframing Assistant
+
+A tool inspired by CBT (Cognitive Behavioral Therapy) designed to help identify and reframe cognitive distortions.
+
+## 🎯 Features
+
+- **Educational Landing Page**: Learn about CBT and cognitive reframing
+- **Interactive Chat**: Share thoughts and receive balanced perspectives
+- **Pattern Recognition**: Identifies cognitive distortions in thinking patterns
+- **Similar Situations**: Shows relatable examples with reframed perspectives
+- **Learning Center**: Explore 13+ cognitive distortions with examples
+- **Multilingual**: Support for English and Spanish
+- **Privacy-First**: No message content stored; only pseudonymous usage counters
+- **Agentic LLM**: Uses Hugging Face Inference API (required for chat)
+- **Streaming Chat**: Incremental assistant messages for a smoother UX
+- **Lightweight Memory**: Assistant considers the last N turns (default 6)
+
+## 📁 Project Structure
+
+```
+re-frame-gradio/
+├── app.py                     # Main Gradio application
+├── requirements.txt           # Python dependencies
+├── README.md                  # This file
+├── cbt_knowledge/             # CBT knowledge base
+│   ├── __init__.py
+│   ├── distortions.py        # Cognitive distortions database
+│   └── reframing_tools.py    # Reframing strategies
+├── ui_components/             # UI components
+│   ├── __init__.py
+│   ├── landing.py            # Landing page
+│   └── learn.py              # Learning center
+└── locales/                   # Translations (optional)
+    ├── en.json               # English
+    └── es.json               # Spanish
+```
+
+## 🧩 Cognitive Distortions Covered
+
+1. **All-or-Nothing Thinking** - Black and white thinking
+2. **Fortune Telling** - Negative predictions
+3. **Catastrophizing** - Expecting the worst
+4. **Mind Reading** - Assuming others' thoughts
+5. **Mental Filter** - Focusing on negatives
+6. **Should Statements** - Rigid rules
+7. **Labeling** - Global negative labels
+8. **Personalization** - Self-blame
+9. **Emotional Reasoning** - Feelings as facts
+10. **Discounting Positives** - Dismissing good things
+11. **Jumping to Conclusions** - Assumptions without evidence
+12. **Magnification/Minimization** - Distorting importance
+13. **Overgeneralization** - Broad conclusions from single events
+
+
+## 🤝 How It Works
+
+1. **Share Your Thoughts**: Type what's on your mind in the chat
+2. **Pattern Detection**: The system identifies thinking patterns
+3. **Balanced Perspectives**: Get alternative ways to view the situation
+4. **Similar Examples**: See how others reframed similar thoughts
+5. **Learn More**: Explore specific distortions in the Learn tab
+
+## ⚠️ Important Disclaimers
+
+- This is intended to be a **helpful tool**, **NEVER** a replacement for professional therapy
+- **NOT** intended for crisis situations or medical advice
+- If you're in crisis, please contact emergency services or a crisis helpline
+- No message content is stored. For quotas and observability, the app records per-user interaction counters using salted hashes and aggregated metrics (no raw usernames, emails, or IPs).
+
+## 🔐 Login, Quotas, and Owner Controls
+
+This Space supports "Login with Hugging Face" for stable and secure per-user quotas.
+
+- The UI includes a Login button. Once logged in, the app receives an OAuth profile and derives a pseudonymous, salted user id.
+- Per-user daily interactions are capped via `HF_AGENT_MAX_INTERACTIONS_PER_USER` (default: 12).
+- An Owner tab is visible only to the Space owner.
+- Environment variables:
+  - `HUGGINGFACEHUB_API_TOKEN` — required: Inference API token (set as a Secret). `HF_TOKEN` is also accepted, but prefer this name.
+  - `HF_AGENT_MAX_INTERACTIONS_PER_USER` — per-user daily cap (default: 12)
+  - `USAGE_SALT` — required: random salt for hashing user identifiers
+  - `AGENT_CALL_LOG_PATH` — path to persist counters (e.g., `/data/agent_calls.json`)
+  - `APP_METRICS_PATH` — path to privacy-preserving metrics (e.g., `/data/app_metrics.json`)
+  - `HF_HOME` — recommended: set to `/data/.huggingface` to persist cache across restarts
+
+Notes:
+- The app never stores raw usernames, emails, IPs, or message content.
+- Configure persistent storage for those JSON files if you want counters to survive Space restarts. If using persistent storage, set `HF_HOME=/data/.huggingface` so model/cache downloads persist too.
+
+### Owner-only Admin
+
+Set the environment variable `OWNER_USER` to your Hugging Face username. The Owner tab will only be shown when the logged-in user matches this username.
+
+- `OWNER_USER` — required to enable Owner tab (e.g., `carlos`)
+
+
+## 🙏 Acknowledgments
+
+- Inspired by CBT principles
+- Original prototype built with Google ADK 
+- Built with Gradio and Hugging Face
+
+## 📄 License
+
+MIT License - See LICENSE file for details
+
+---

agents/__init__.py

@@ -0,0 +1,7 @@
+"""
+CBT Agent module backed by Hugging Face Inference API
+"""
+
+from .cbt_agent import CBTAgent
+
+__all__ = ['CBTAgent']

agents/cbt_agent.py

@@ -0,0 +1,242 @@
+"""
+CBT Agent implementation using Hugging Face Inference API directly.
+
+This avoids smolagents version drift and works cleanly on Spaces.
+Adds optional provider, billing, and timeout support plus true
+token streaming for lower-latency responses in Spaces.
+"""
+
+import os
+from collections.abc import Iterable
+
+from huggingface_hub import InferenceClient
+
+try:  # Newer hub versions expose a specific timeout error
+    from huggingface_hub import InferenceTimeoutError
+except Exception:  # pragma: no cover
+
+    class InferenceTimeoutError(Exception):  # type: ignore
+        pass
+
+
+class CBTAgent:
+    """Agent that composes warm CBT responses using HF Inference API.
+
+    Args:
+        model_name: HF model id or endpoint URL to use.
+        provider: Optional provider routing (e.g., "together", "groq", "hf-inference").
+        bill_to: Optional org to bill (Enterprise Hub).
+        timeout: Request timeout in seconds.
+        use_local: Ignored; kept for backward compatibility.
+    """
+
+    def __init__(
+        self,
+        model_name: str | None = None,
+        *,
+        provider: str | None = None,
+        bill_to: str | None = None,
+        timeout: float | None = None,
+        use_local: bool = False,  # use_local ignored
+    ):
+        self.model_name = model_name or os.getenv("MODEL_NAME", "meta-llama/Llama-3.1-8B-Instruct")
+
+        # Optional routing / billing / timeout via env overrides
+        self.provider = provider or os.getenv("HF_PROVIDER")
+        self.bill_to = bill_to or os.getenv("HF_BILL_TO")
+        # Parse env timeout if not provided
+        if timeout is None:
+            try:
+                timeout_env = os.getenv("HF_TIMEOUT_SECONDS")
+                timeout = float(timeout_env) if timeout_env else None
+            except Exception:
+                timeout = None
+        self.timeout = timeout
+
+        token = os.getenv("HUGGINGFACEHUB_API_TOKEN") or os.getenv("HF_TOKEN")
+        if not token:
+            raise RuntimeError("HF token missing: set HF_TOKEN or HUGGINGFACEHUB_API_TOKEN")
+
+        # Initialize client with explicit named params to satisfy typing
+        self.client = InferenceClient(
+            model=self.model_name,
+            provider=(self.provider if self.provider is not None else None),  # type: ignore[arg-type]
+            token=token,
+            timeout=self.timeout,
+            bill_to=self.bill_to,
+        )
+
+    def _get_system_prompt(self) -> str:
+        return (
+            "You are a compassionate CBT assistant. Identify likely cognitive distortions, "
+            "validate feelings, and suggest balanced, realistic alternatives. Keep responses "
+            "concise, supportive, and practical. This is self-help guidance, not therapy."
+        )
+
+    def _generate(self, prompt: str, messages: list[dict] | None = None) -> str:
+        # Prefer chat-completions if available
+        try:
+            msgs = messages or [
+                {"role": "system", "content": self._get_system_prompt()},
+                {"role": "user", "content": prompt},
+            ]
+            if hasattr(self.client, "chat") and hasattr(self.client.chat, "completions"):
+                resp = self.client.chat.completions.create(
+                    model=self.model_name,
+                    messages=msgs,
+                    max_tokens=400,
+                    temperature=0.6,
+                )
+                msg = getattr(resp.choices[0], "message", None)
+                return getattr(msg, "content", "") or ""
+            if hasattr(self.client, "chat_completion"):
+                resp = self.client.chat_completion(
+                    messages=msgs,
+                    max_tokens=400,
+                    temperature=0.6,
+                )
+                choices = resp.get("choices") or []
+                if choices:
+                    return choices[0].get("message", {}).get("content", "")
+        except Exception:
+            pass
+
+        # Fallback to plain text generation
+        return self.client.text_generation(
+            prompt if prompt else (messages[-1]["content"] if messages else ""),
+            max_new_tokens=400,
+            temperature=0.6,
+            return_full_text=False,
+        )
+
+    def _build_messages(self, message: str, context: list[dict] | None = None) -> list[dict]:
+        messages: list[dict] = [
+            {"role": "system", "content": self._get_system_prompt()},
+        ]
+        if context:
+            turns = context[-3:]
+            for turn in turns:
+                u = turn.get("user", "")
+                a = turn.get("assistant", "")
+                if u:
+                    messages.append({"role": "user", "content": u})
+                if a:
+                    messages.append({"role": "assistant", "content": a})
+        messages.append({"role": "user", "content": message})
+        return messages
+
+    def analyze_thought(self, thought: str) -> dict:
+        from cbt_knowledge import detect_distortions, find_similar_situations
+
+        distortions = detect_distortions(thought)
+        codes = [c for c, _ in distortions]
+        prompt = (
+            f"Thought: {thought}\n"
+            f"Detected codes: {', '.join(codes) if codes else 'none'}\n"
+            "Write a gentle, balanced reframe (2-4 sentences). Validate feelings first."
+        )
+        reframe = self._generate(prompt)
+
+        primary = codes[0] if codes else None
+        similar = find_similar_situations(primary) if primary else []
+        return {
+            "thought": thought,
+            "distortions": distortions,
+            "reframe": reframe,
+            "similar_situations": similar,
+        }
+
+    def generate_response(self, message: str, context: list[dict] | None = None) -> str:
+        """Return a full assistant response (non-streaming)."""
+        messages = self._build_messages(message, context)
+        return self._generate(prompt="", messages=messages)
+
+    def stream_generate_response(
+        self, message: str, context: list[dict] | None = None
+    ) -> Iterable[str]:
+        """Yield assistant tokens via provider streaming if supported.
+
+        Falls back to a single full message chunk when streaming
+        is not supported by the provider/client.
+        """
+        messages = self._build_messages(message, context)
+
+        # Try OpenAI-compatible chat streaming first
+        try:
+            if hasattr(self.client, "chat") and hasattr(self.client.chat, "completions"):
+                stream = self.client.chat.completions.create(
+                    model=self.model_name,
+                    messages=messages,
+                    temperature=0.6,
+                    max_tokens=400,
+                    stream=True,
+                )
+                for chunk in stream:  # ChatCompletionStreamOutput-like
+                    # Handle both object-like and dict-like chunks
+                    delta = (
+                        getattr(chunk.choices[0], "delta", None)
+                        if hasattr(chunk, "choices")
+                        else None
+                    )
+                    content = None
+                    if delta is not None:
+                        content = getattr(delta, "content", None)
+                    elif isinstance(chunk, dict):
+                        content = chunk.get("choices", [{}])[0].get("delta", {}).get("content")
+                    if content:
+                        yield content
+                return
+            if hasattr(self.client, "chat_completion"):
+                stream = self.client.chat_completion(
+                    messages=messages,
+                    temperature=0.6,
+                    max_tokens=400,
+                    stream=True,
+                )
+                for chunk in stream:
+                    # older dict-shaped stream
+                    content = (chunk.get("choices") or [{}])[0].get("delta", {}).get("content")
+                    if content:
+                        yield content
+                return
+        except InferenceTimeoutError as e:  # pragma: no cover
+            # Surface a short message; UI will present it
+            yield f"[timeout] {e}"
+            return
+        except Exception:
+            # Fall through to plain generation
+            pass
+
+        # Fallback: text generation streaming if available
+        try:
+            gen = self.client.text_generation(
+                messages[-1]["content"],
+                max_new_tokens=400,
+                temperature=0.6,
+                stream=True,
+                return_full_text=False,
+            )
+            for token in gen:
+                if token:
+                    yield str(token)
+            return
+        except Exception:
+            pass
+
+        # Final fallback: non-streaming
+        yield self.generate_response(message, context)
+
+    def get_crisis_response(self) -> str:
+        return (
+            "I'm concerned about what you're sharing and want you to know that support is "
+            "available.\n\n"
+            "Immediate help: see international resources at "
+            "https://blog.opencounseling.com/suicide-hotlines/\n\n"
+            "You don't have to go through this alone. Please reach out to a professional who "
+            "can provide the support you deserve."
+        )
+
+
+def create_simple_cbt_assistant():
+    """Backwards-compatible alias."""
+    return CBTAgent()

app.py

@@ -1,7 +1,969 @@
+"""
+Re-frame: Cognitive Reframing Assistant
+A Gradio-based CBT tool for identifying and reframing cognitive distortions
+"""
+
+import hashlib
+import json
+import os
+from datetime import datetime
+from typing import Optional
+
 import gradio as gr
 
-def greet(name):
-    return "Hello " + name + "!!"
+# Import our CBT knowledge base
+from cbt_knowledge import (
+    COGNITIVE_DISTORTIONS,
+    find_similar_situations,
+)
+
+# Import UI components
+from ui_components.landing import create_landing_tab
+from ui_components.learn import create_learn_tab
+
+# Agentic LLM support (Hugging Face Inference API)
+try:
+    from agents import CBTAgent
+
+    AGENT_AVAILABLE = True
+except Exception:
+    CBTAgent = None  # type: ignore
+    AGENT_AVAILABLE = False
+
+
+# Load translations
+def load_translations():
+    """Load translation files for internationalization"""
+    translations = {}
+    for lang in ['en', 'es']:
+        try:
+            with open(f'locales/{lang}.json', encoding='utf-8') as f:
+                translations[lang] = json.load(f)
+        except FileNotFoundError:
+            # Fallback to embedded translations if files don't exist
+            pass
+
+    # Fallback translations
+    if 'en' not in translations:
+        translations['en'] = {
+            "app_title": "🧠 re-frame: Cognitive Reframing Assistant",
+            "app_description": "Using CBT principles to help you find balanced perspectives",
+            "welcome": {
+                "title": "Welcome to re-frame",
+                "subtitle": "Find a kinder perspective",
+                "description": (
+                    "Using ideas from Cognitive Behavioral Therapy (CBT), we help you notice "
+                    "thinking patterns and explore gentler, more balanced perspectives."
+                ),
+                "how_it_works": "How it works",
+                "step1": "Share your thoughts",
+                "step1_desc": "Tell us what's on your mind",
+                "step2": "Identify patterns",
+                "step2_desc": "We'll help spot thinking traps",
+                "step3": "Find balance",
+                "step3_desc": "Explore alternative perspectives",
+                "start_chat": "Start Chat",
+                "disclaimer": "Important: This is a self-help tool, not therapy or medical advice.",
+                "privacy": "Privacy: No data is stored beyond your session.",
+            },
+            "chat": {
+                "title": "Chat",
+                "placeholder": "Share what's on your mind...",
+                "send": "Send",
+                "clear": "New Session",
+                "thinking": "Thinking...",
+                "distortions_found": "Thinking patterns identified:",
+                "reframe_suggestion": "Alternative perspective:",
+                "similar_situations": "Similar situations:",
+                "try_this": "You might try:",
+            },
+            "learn": {
+                "title": "Learn",
+                "select_distortion": "Select a thinking pattern to explore",
+                "definition": "Definition",
+                "examples": "Common Examples",
+                "strategies": "Reframing Strategies",
+                "actions": "Small Steps to Try",
+            },
+        }
+
+    if 'es' not in translations:
+        translations['es'] = {
+            "app_title": "🧠 re-frame: Asistente de Reencuadre Cognitivo",
+            "app_description": (
+                "Usando principios de TCC para ayudarte a encontrar perspectivas equilibradas"
+            ),
+            "welcome": {
+                "title": "Bienvenido a re-frame",
+                "subtitle": "Encuentra una perspectiva más amable",
+                "description": (
+                    "Usando ideas de la Terapia Cognitivo-Conductual (TCC), te ayudamos a notar "
+                    "patrones de pensamiento y explorar perspectivas más gentiles y equilibradas."
+                ),
+                "how_it_works": "Cómo funciona",
+                "step1": "Comparte tus pensamientos",
+                "step1_desc": "Cuéntanos qué piensas",
+                "step2": "Identifica patrones",
+                "step2_desc": "Te ayudamos a detectar trampas mentales",
+                "step3": "Encuentra balance",
+                "step3_desc": "Explora perspectivas alternativas",
+                "start_chat": "Iniciar Chat",
+                "disclaimer": (
+                    "Importante: Esta es una herramienta de autoayuda, "
+                    "no terapia ni consejo médico."
+                ),
+                "privacy": "Privacidad: No se almacenan datos más allá de tu sesión.",
+            },
+            "chat": {
+                "title": "Chat",
+                "placeholder": "Comparte lo que piensas...",
+                "send": "Enviar",
+                "clear": "Nueva Sesión",
+                "thinking": "Pensando...",
+                "distortions_found": "Patrones de pensamiento identificados:",
+                "reframe_suggestion": "Perspectiva alternativa:",
+                "similar_situations": "Situaciones similares:",
+                "try_this": "Podrías intentar:",
+            },
+            "learn": {
+                "title": "Aprender",
+                "select_distortion": "Selecciona un patrón de pensamiento para explorar",
+                "definition": "Definición",
+                "examples": "Ejemplos Comunes",
+                "strategies": "Estrategias de Reencuadre",
+                "actions": "Pequeños Pasos a Intentar",
+            },
+        }
+
+    return translations
+
+
+class CBTChatbot:
+    """Main chatbot class for handling CBT conversations"""
+
+    def __init__(self, language='en', memory_size: int = 6):
+        self.language = language
+        self.translations = load_translations()
+        self.t = self.translations.get(language, self.translations['en'])
+        self.conversation_history: list[list[str]] = []
+        self.identified_distortions: list[tuple[str, float]] = []
+        self.memory_size = max(2, int(memory_size))
+
+    def _history_to_context(self, history: list[list[str]]) -> list[dict]:
+        """Convert Chatbot history [[user, assistant], ...] to agent context[{user,assistant}]"""
+        ctx: list[dict] = []
+        for turn in history or []:
+            if isinstance(turn, list | tuple) and len(turn) == 2:
+                ctx.append({"user": turn[0] or "", "assistant": turn[1] or ""})
+        return ctx[-self.memory_size :]
+
+    def process_message(
+        self,
+        message: str,
+        history: list[list[str]],
+        use_agent: bool = False,
+        agent: Optional["CBTAgent"] = None,
+    ) -> tuple[list[list[str]], str, str, str]:
+        """
+        Process user message and generate response with CBT analysis
+
+        Returns:
+            - Updated chat history
+            - Identified distortions display
+            - Reframe suggestion
+            - Similar situations display
+        """
+        if not message or message.strip() == "":
+            return history or [], "", "", ""
+
+        # Add user message to history
+        history = history or []
+
+        # Agentic path only: remove non-LLM fallback
+        if use_agent and agent is not None:
+            try:
+                analysis = agent.analyze_thought(message)
+                response = agent.generate_response(
+                    message, context=self._history_to_context(history)
+                )
+
+                distortions_display = self._format_distortions(analysis.get("distortions", []))
+                reframe_display = analysis.get("reframe", "")
+                primary = analysis.get("distortions", [])
+                primary_code = primary[0][0] if primary else None
+                situations_display = (
+                    self._format_similar_situations(primary_code) if primary_code else ""
+                )
+            except Exception as e:
+                # Do not fallback to local heuristics
+                history.append([message, f"Agent error: {e}"])
+                return history, "", "", ""
+        else:
+            # Non-agent mode disabled
+            history.append(
+                [message, "Agent-only mode: please enable the agent to generate responses."]
+            )
+            return history, "", "", ""
+
+        # Update history with memory cap
+        history.append([message, response])
+        if len(history) > self.memory_size:
+            history = history[-self.memory_size :]
+
+        return history, distortions_display, reframe_display, situations_display
+
+    def _format_distortions(self, distortions: list[tuple[str, float]]) -> str:
+        """Format detected distortions for display"""
+        if not distortions:
+            return ""
+
+        lines = [f"### {self.t['chat']['distortions_found']}\n"]
+        for code, confidence in distortions[:3]:  # Show top 3
+            for _key, info in COGNITIVE_DISTORTIONS.items():
+                if info['code'] == code:
+                    lines.append(f"**{info['name']}** ({confidence * 100:.0f}% match)")
+                    lines.append(f"*{info['definition']}*\n")
+                    break
+
+        return "\n".join(lines)
+
+    def _format_similar_situations(self, distortion_code: str) -> str:
+        """Format similar situations for display"""
+        situations = find_similar_situations(distortion_code, num_situations=2)
+        if not situations:
+            return ""
+
+        lines = [f"### {self.t['chat']['similar_situations']}\n"]
+        for i, situation in enumerate(situations, 1):
+            lines.append(f"**Example {i}:** {situation['situation']}")
+            lines.append(f"*Distorted:* \"{situation['distorted']}\"")
+            lines.append(f"*Reframed:* \"{situation['reframed']}\"\n")
+
+        return "\n".join(lines)
+
+    def clear_session(self):
+        """Clear the conversation session"""
+        self.conversation_history = []
+        self.identified_distortions = []
+        return [], "", "", ""
+
+
+def create_app(language='en'):
+    """Create and configure the Gradio application"""
+
+    # Initialize chatbot
+    chatbot = CBTChatbot(language)
+    t = chatbot.t
+
+    # Custom CSS for better styling
+    custom_css = """
+    .gradio-container {
+        font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+    }
+    .gr-button-primary {
+        background-color: #2563eb !important;
+        border-color: #2563eb !important;
+    }
+    .gr-button-primary:hover {
+        background-color: #1e40af !important;
+    }
+    .info-box {
+        background-color: #f0f9ff;
+        border: 1px solid #3b82f6;
+        border-radius: 8px;
+        padding: 12px;
+        margin: 8px 0;
+    }
+    """
+
+    with gr.Blocks(title=t['app_title'], theme=gr.themes.Soft(), css=custom_css) as app:
+        gr.Markdown(f"# {t['app_title']}")
+        gr.Markdown(f"*{t['app_description']}*")
+
+        with gr.Tabs():
+            # Welcome Tab
+            with gr.Tab(t['welcome']['title']):
+                create_landing_tab(t['welcome'])
+
+            # Chat Tab
+            with gr.Tab(t['chat']['title']):
+                # Settings row (agentic only)
+                with gr.Row():
+                    model_name = gr.Textbox(
+                        label="Model (HF)",
+                        value=os.getenv("MODEL_NAME", "meta-llama/Llama-3.1-8B-Instruct"),
+                        info=(
+                            "Requires HF Inference API token (HF_TOKEN or HUGGINGFACEHUB_API_TOKEN)"
+                        ),
+                    )
+                    gr.Markdown("Agentic mode only. No local fallback. Set `HF_TOKEN` in Secrets.")
+                    gr.LoginButton()
+                billing_notice = gr.Markdown("")
+
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        chatbot_ui = gr.Chatbot(height=400, label="Conversation")
+
+                        with gr.Row():
+                            msg_input = gr.Textbox(
+                                label="", placeholder=t['chat']['placeholder'], scale=4
+                            )
+                            send_btn = gr.Button(t['chat']['send'], variant="primary", scale=1)
+
+                        clear_btn = gr.Button(t['chat']['clear'], variant="secondary")
+
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Analysis")
+                        distortions_output = gr.Markdown(label="Patterns Detected")
+                        reframe_output = gr.Markdown(label="Reframe Suggestion")
+                        situations_output = gr.Markdown(label="Similar Situations")
+
+                # Internal state for agent instance and agentic enable flag
+                agent_state = gr.State(value=None)
+                agentic_enabled_state = gr.State(value=True)
+                # Admin runtime settings (e.g., per-user limit override)
+                admin_state = gr.State(value={"per_user_limit_override": None})
+
+                # Connect chat interface (streaming)
+                def _ensure_hf_token_env():
+                    # Honor either HF_TOKEN or HUGGINGFACEHUB_API_TOKEN
+                    token = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN")
+                    if token and not os.getenv("HUGGINGFACEHUB_API_TOKEN"):
+                        os.environ["HUGGINGFACEHUB_API_TOKEN"] = token
+
+                def _stream_chunks(text: str, chunk_words: int = 12):
+                    words = (text or "").split()
+                    buf = []
+                    for i, w in enumerate(words, 1):
+                        buf.append(w)
+                        if i % chunk_words == 0:
+                            yield " ".join(buf)
+                            buf = []
+                    if buf:
+                        yield " ".join(buf)
+
+                # Budget guard helpers
+                def _get_call_log_path():
+                    return os.getenv("AGENT_CALL_LOG_PATH", "/tmp/agent_calls.json")
+
+                # Simple privacy-preserving metrics (no raw PII/content)
+                def _get_metrics_path():
+                    return os.getenv("APP_METRICS_PATH", "/tmp/app_metrics.json")
+
+                def _load_call_log():
+                    try:
+                        with open(_get_call_log_path(), encoding="utf-8") as f:
+                            return json.load(f)
+                    except Exception:
+                        return {}
+
+                def _load_metrics():
+                    try:
+                        with open(_get_metrics_path(), encoding="utf-8") as f:
+                            return json.load(f)
+                    except Exception:
+                        return {}
+
+                def _save_call_log(data):
+                    try:
+                        with open(_get_call_log_path(), "w", encoding="utf-8") as f:
+                            json.dump(data, f)
+                    except Exception:
+                        pass
+
+                def _save_metrics(data):
+                    try:
+                        with open(_get_metrics_path(), "w", encoding="utf-8") as f:
+                            json.dump(data, f)
+                    except Exception:
+                        pass
+
+                def _today_key():
+                    return datetime.utcnow().strftime("%Y-%m-%d")
+
+                # Metrics helpers
+                def _metrics_today():
+                    m = _load_metrics()
+                    return m.get(_today_key(), {})
+
+                def _write_metrics_today(d):
+                    m = _load_metrics()
+                    m[_today_key()] = d
+                    _save_metrics(m)
+
+                def _inc_metric(key: str, inc: int = 1):
+                    d = _metrics_today()
+                    d[key] = int(d.get(key, 0)) + inc
+                    _write_metrics_today(d)
+
+                def _record_distortion_counts(codes: list[str]):
+                    if not codes:
+                        return
+                    d = _metrics_today()
+                    dist = d.get("distortion_counts", {})
+                    if not isinstance(dist, dict):
+                        dist = {}
+                    for c in codes:
+                        dist[c] = int(dist.get(c, 0)) + 1
+                    d["distortion_counts"] = dist
+                    _write_metrics_today(d)
+
+                def _record_response_chars(n: int):
+                    d = _metrics_today()
+                    d["response_chars_total"] = int(d.get("response_chars_total", 0)) + max(
+                        0, int(n)
+                    )
+                    d["response_count"] = int(d.get("response_count", 0)) + 1
+                    _write_metrics_today(d)
+
+                def _calls_today():
+                    data = _load_call_log()
+                    return int(data.get(_today_key(), 0))
+
+                def _inc_calls_today():
+                    data = _load_call_log()
+                    key = _today_key()
+                    data[key] = int(data.get(key, 0)) + 1
+                    _save_call_log(data)
+
+                def _agentic_budget_allows():
+                    hard = os.getenv("HF_AGENT_HARD_DISABLE", "").lower() in ("1", "true", "yes")
+                    if hard:
+                        return False
+                    limit = os.getenv("HF_AGENT_MAX_CALLS_PER_DAY")
+                    if not limit:
+                        return True
+                    try:
+                        limit_i = int(limit)
+                    except Exception:
+                        return True
+                    return _calls_today() < max(0, limit_i)
+
+                def respond_stream(
+                    message,
+                    history,
+                    model_value,
+                    agent_obj,
+                    agentic_ok,
+                    admin_settings,
+                    request: "gr.Request",
+                    profile: "gr.OAuthProfile | None" = None,
+                ):
+                    if not message:
+                        yield history, "", "", "", agent_obj, "", agentic_ok
+                        return
+
+                    budget_ok = _agentic_budget_allows()
+                    notice = ""
+
+                    # Compute user id (salted hash) for per-user quotas
+                    def _user_id(req: "gr.Request", prof: "gr.OAuthProfile | None") -> str:
+                        try:
+                            salt = os.getenv("USAGE_SALT", "reframe_salt")
+                            # Prefer OAuth profile when available
+                            if prof is not None:
+                                # Try common fields in OAuth profile
+                                username = None
+                                for key in (
+                                    "preferred_username",
+                                    "username",
+                                    "login",
+                                    "name",
+                                    "sub",
+                                    "id",
+                                ):
+                                    try:
+                                        if hasattr(prof, key):
+                                            username = getattr(prof, key)
+                                        elif isinstance(prof, dict) and key in prof:
+                                            username = prof[key]
+                                        if username:
+                                            break
+                                    except Exception:
+                                        pass
+                                raw = f"oauth:{username or 'unknown'}"
+                            # req is expected to be provided by Gradio
+                            elif getattr(req, "username", None):
+                                raw = f"user:{req.username}"
+                            else:
+                                ip = getattr(getattr(req, "client", None), "host", "?")
+                                ua = (
+                                    dict(req.headers).get("user-agent", "?")
+                                    if getattr(req, "headers", None)
+                                    else "?"
+                                )
+                                sess = getattr(req, "session_hash", None) or "?"
+                                raw = f"ipua:{ip}|{ua}|{sess}"
+                            return hashlib.sha256(f"{salt}|{raw}".encode()).hexdigest()
+                        except Exception:
+                            return "anon"
+
+                    user_id = _user_id(request, profile)
+
+                    # Per-user interaction quota (counts 1 per message)
+                    def _interactions_today(uid: str) -> int:
+                        data = _load_call_log()
+                        day = _today_key()
+                        day_blob = data.get(day, {}) if isinstance(data.get(day, {}), dict) else {}
+                        inter = (
+                            day_blob.get("interactions", {})
+                            if isinstance(day_blob.get("interactions", {}), dict)
+                            else {}
+                        )
+                        return int(inter.get(uid, 0))
+
+                    def _inc_interactions_today(uid: str):
+                        data = _load_call_log()
+                        day = _today_key()
+                        day_blob = data.get(day, {}) if isinstance(data.get(day, {}), dict) else {}
+                        inter = (
+                            day_blob.get("interactions", {})
+                            if isinstance(day_blob.get("interactions", {}), dict)
+                            else {}
+                        )
+                        inter[uid] = int(inter.get(uid, 0)) + 1
+                        day_blob["interactions"] = inter
+                        data[day] = day_blob
+                        _save_call_log(data)
+
+                    max_interactions_env = os.getenv("HF_AGENT_MAX_INTERACTIONS_PER_USER")
+                    try:
+                        # Default to a generous 12 if not configured
+                        per_user_limit_env = (
+                            int(max_interactions_env) if max_interactions_env else 12
+                        )
+                    except Exception:
+                        per_user_limit_env = 12
+                    per_user_limit = per_user_limit_env
+                    # Admin override (runtime)
+                    try:
+                        override = None
+                        if isinstance(admin_settings, dict):
+                            override = admin_settings.get("per_user_limit_override")
+                        if isinstance(override, int | float) and int(override) > 0:
+                            per_user_limit = int(override)
+                    except Exception:
+                        pass
+                    if per_user_limit is not None and _interactions_today(user_id) >= max(
+                        0, per_user_limit
+                    ):
+                        _inc_metric("blocked_interactions")
+                        yield (
+                            history or [],
+                            "",
+                            "",
+                            "",
+                            agent_obj,
+                            f"Per-user limit reached ({per_user_limit} interactions).",
+                            agentic_ok,
+                        )
+                        return
+                    if not AGENT_AVAILABLE:
+                        yield (
+                            history or [],
+                            "",
+                            "",
+                            "",
+                            agent_obj,
+                            "Agent not available. Check HF token and model name.",
+                            agentic_ok,
+                        )
+                        return
+                    if not agentic_ok:
+                        yield (
+                            history or [],
+                            "",
+                            "",
+                            "",
+                            agent_obj,
+                            "Agentic mode disabled due to a prior quota/billing error.",
+                            agentic_ok,
+                        )
+                        return
+                    if not budget_ok:
+                        yield (
+                            history or [],
+                            "",
+                            "",
+                            "",
+                            agent_obj,
+                            "Daily budget reached. Set HF_AGENT_MAX_CALLS_PER_DAY or try tomorrow.",
+                            agentic_ok,
+                        )
+                        return
+                    # Count one interaction for this user upfront
+                    _inc_interactions_today(user_id)
+
+                    # Lazily initialize agent if requested
+                    _ensure_hf_token_env()
+                    if agent_obj is None:
+                        try:
+                            agent_obj = CBTAgent(model_name=model_value)
+                        except Exception as e:
+                            err = str(e)
+                            yield (
+                                history or [],
+                                "",
+                                "",
+                                "",
+                                agent_obj,
+                                f"Agent failed to initialize: {err}",
+                                agentic_ok,
+                            )
+                            return
+
+                    # Prepare side panels first for a snappy UI
+                    try:
+                        analysis = agent_obj.analyze_thought(message)
+                        distortions_display = chatbot._format_distortions(
+                            analysis.get("distortions", [])
+                        )
+                        reframe_display = analysis.get("reframe", "")
+                        primary = analysis.get("distortions", [])
+                        primary_code = primary[0][0] if primary else None
+                        situations_display = (
+                            chatbot._format_similar_situations(primary_code) if primary_code else ""
+                        )
+                        # Metrics: record this interaction
+                        _inc_metric("total_interactions")
+                        _record_distortion_counts([c for c, _ in analysis.get("distortions", [])])
+                        _inc_calls_today()
+                    except Exception as e:
+                        distortions_display = reframe_display = situations_display = ""
+                        # Detect quota/billing signals and permanently disable agent for this run
+                        msg = str(e).lower()
+                        if any(
+                            k in msg
+                            for k in [
+                                "quota",
+                                "limit",
+                                "billing",
+                                "payment",
+                                "insufficient",
+                                "402",
+                                "429",
+                            ]
+                        ):
+                            agentic_ok = False
+                            notice = "Agentic mode disabled due to quota/billing error."
+                        else:
+                            notice = f"Agent analysis failed: {e}"
+                        _inc_metric("agent_errors")
+                        yield (
+                            history or [],
+                            distortions_display,
+                            reframe_display,
+                            situations_display,
+                            agent_obj,
+                            notice,
+                            agentic_ok,
+                        )
+                        return
+
+                    # Start streaming the assistant reply
+                    history = history or []
+                    history.append([message, ""])  # placeholder for assistant
+                    # Enforce memory cap while streaming
+                    if len(history) > chatbot.memory_size:
+                        history = history[-chatbot.memory_size :]
+
+                    # Choose response source: true token streaming via HF Inference
+                    try:
+                        _inc_calls_today()
+                        stream = getattr(agent_obj, "stream_generate_response", None)
+                        if callable(stream):
+                            token_iter = stream(
+                                message, context=chatbot._history_to_context(history[:-1])
+                            )
+                        else:
+                            # Fallback to non-streaming
+                            def _one_shot():
+                                yield agent_obj.generate_response(
+                                    message, context=chatbot._history_to_context(history[:-1])
+                                )
+
+                            token_iter = _one_shot()
+                    except Exception as e:
+                        _inc_metric("agent_errors")
+                        yield (
+                            history,
+                            distortions_display,
+                            reframe_display,
+                            situations_display,
+                            agent_obj,
+                            f"Agent response failed: {e}",
+                            agentic_ok,
+                        )
+                        return
+
+                    acc = ""
+                    for chunk in token_iter:
+                        if not chunk:
+                            continue
+                        acc += str(chunk)
+                        history[-1][1] = acc
+                        # yield streaming frame
+                        yield (
+                            history,
+                            distortions_display,
+                            reframe_display,
+                            situations_display,
+                            agent_obj,
+                            notice,
+                            agentic_ok,
+                        )
+
+                    # Final yield ensures the last state is consistent
+                    _record_response_chars(len(acc))
+                    # Show remaining interactions
+                    try:
+                        remaining = (
+                            None
+                            if per_user_limit is None
+                            else max(0, per_user_limit - _interactions_today(user_id))
+                        )
+                        if remaining is not None:
+                            notice = (
+                                notice + f"\nRemaining interactions today: {remaining}"
+                            ).strip()
+                    except Exception:
+                        pass
+                    yield (
+                        history,
+                        distortions_display,
+                        reframe_display,
+                        situations_display,
+                        agent_obj,
+                        notice,
+                        agentic_ok,
+                    )
+
+                def clear_input():
+                    return ""
+
+                msg_input.submit(
+                    respond_stream,
+                    inputs=[
+                        msg_input,
+                        chatbot_ui,
+                        model_name,
+                        agent_state,
+                        agentic_enabled_state,
+                        admin_state,
+                    ],
+                    outputs=[
+                        chatbot_ui,
+                        distortions_output,
+                        reframe_output,
+                        situations_output,
+                        agent_state,
+                        billing_notice,
+                        agentic_enabled_state,
+                    ],
+                ).then(clear_input, outputs=[msg_input])
+
+                send_btn.click(
+                    respond_stream,
+                    inputs=[
+                        msg_input,
+                        chatbot_ui,
+                        model_name,
+                        agent_state,
+                        agentic_enabled_state,
+                        admin_state,
+                    ],
+                    outputs=[
+                        chatbot_ui,
+                        distortions_output,
+                        reframe_output,
+                        situations_output,
+                        agent_state,
+                        billing_notice,
+                        agentic_enabled_state,
+                    ],
+                ).then(clear_input, outputs=[msg_input])
+
+                def _clear_session_and_notice():
+                    h, d, r, s = chatbot.clear_session()
+                    return h, d, r, s, ""
+
+                clear_btn.click(
+                    _clear_session_and_notice,
+                    outputs=[
+                        chatbot_ui,
+                        distortions_output,
+                        reframe_output,
+                        situations_output,
+                        billing_notice,
+                    ],
+                )
+
+            # Learn Tab
+            with gr.Tab(t['learn']['title']):
+                create_learn_tab(t['learn'], COGNITIVE_DISTORTIONS)
+
+            # Owner Tab (visible content only for Space owner)
+            with gr.Tab("Owner"):
+                # Locked panel shown to non-admins
+                locked_panel = gr.Column(visible=True)
+                with locked_panel:
+                    gr.Markdown("### Owner only\nPlease log in with your Hugging Face account.")
+
+                # Admin panel
+                admin_panel = gr.Column(visible=False)
+                with admin_panel:
+                    gr.Markdown("## Admin Dashboard")
+                    admin_summary = gr.Markdown("")
+                    admin_limit_info = gr.Markdown("")
+                    with gr.Row():
+                        override_tb = gr.Textbox(
+                            label="Per-user interaction limit override (blank to clear)"
+                        )
+                        set_override_btn = gr.Button("Set Limit Override", variant="secondary")
+                        refresh_btn = gr.Button("Refresh Metrics", variant="secondary")
+
+                def _owner_is(profile: "gr.OAuthProfile | None") -> bool:
+                    try:
+                        owner = (os.getenv("OWNER_USER") or "").strip().lower()
+                        if not owner:
+                            return False
+                        # Try common profile fields
+                        username = None
+                        for key in ("preferred_username", "username", "login", "name", "sub", "id"):
+                            try:
+                                if hasattr(profile, key):
+                                    username = getattr(profile, key)
+                                elif isinstance(profile, dict) and key in profile:
+                                    username = profile[key]
+                                if username:
+                                    break
+                            except Exception:
+                                pass
+                        if not username:
+                            return False
+                        return str(username).lower() == owner
+                    except Exception:
+                        return False
+
+                def _metrics_paths():
+                    return (
+                        os.getenv("APP_METRICS_PATH", "/tmp/app_metrics.json"),
+                        os.getenv("AGENT_CALL_LOG_PATH", "/tmp/agent_calls.json"),
+                    )
+
+                def _read_json(path: str) -> dict:
+                    try:
+                        with open(path, encoding="utf-8") as f:
+                            return json.load(f)
+                    except Exception:
+                        return {}
+
+                def _summarize_metrics_md() -> str:
+                    mpath, _ = _metrics_paths()
+                    data = _read_json(mpath)
+                    if not data:
+                        return "No metrics recorded yet."
+                    # Summarize last 7 days
+                    days = sorted(data.keys())[-7:]
+                    total = blocked = errors = resp_chars = resp_count = 0
+                    dist_counts: dict[str, int] = {}
+                    for d in days:
+                        day = data.get(d, {}) or {}
+                        total += int(day.get("total_interactions", 0))
+                        blocked += int(day.get("blocked_interactions", 0))
+                        errors += int(day.get("agent_errors", 0))
+                        resp_chars += int(day.get("response_chars_total", 0))
+                        resp_count += int(day.get("response_count", 0))
+                        dist = day.get("distortion_counts", {})
+                        if isinstance(dist, dict):
+                            for k, v in dist.items():
+                                dist_counts[k] = int(dist_counts.get(k, 0)) + int(v)
+                    avg_len = (resp_chars / resp_count) if resp_count else 0
+                    top = sorted(dist_counts.items(), key=lambda x: x[1], reverse=True)[:5]
+                    lines = [
+                        "### Usage (last 7 days)",
+                        f"- Total interactions: {total}",
+                        f"- Blocked interactions: {blocked}",
+                        f"- Agent errors: {errors}",
+                        f"- Avg response length: {avg_len:.0f} chars",
+                        "",
+                        "### Top cognitive patterns",
+                    ]
+                    if top:
+                        for k, v in top:
+                            lines.append(f"- {k}: {v}")
+                    else:
+                        lines.append("- None recorded")
+                    return "\n".join(lines)
+
+                def _limit_info_md(settings: dict | None) -> str:
+                    env_val = os.getenv("HF_AGENT_MAX_INTERACTIONS_PER_USER")
+                    try:
+                        env_limit = int(env_val) if env_val else 12
+                    except Exception:
+                        env_limit = 12
+                    override = None
+                    if isinstance(settings, dict):
+                        override = settings.get("per_user_limit_override")
+                    effective = (
+                        int(override)
+                        if isinstance(override, int | float) and int(override) > 0
+                        else env_limit
+                    )
+                    return (
+                        f"Per-user daily limit: {effective} (env: {env_limit}, override: "
+                        f"{override if override else 'None'})"
+                    )
+
+                def show_admin(profile: "gr.OAuthProfile | None"):
+                    visible = _owner_is(profile)
+                    return (
+                        gr.update(visible=visible),
+                        gr.update(visible=not visible),
+                        _summarize_metrics_md() if visible else "",
+                        _limit_info_md(admin_state.value if hasattr(admin_state, "value") else None)
+                        if visible
+                        else "",
+                    )
+
+                def admin_set_limit(override_text: str, settings: dict | None):
+                    # Only update runtime state; does not change env var
+                    try:
+                        if settings is None or not isinstance(settings, dict):
+                            settings = {"per_user_limit_override": None}
+                        override = None
+                        if override_text and override_text.strip():
+                            override = int(override_text.strip())
+                            if override <= 0:
+                                override = None
+                        settings["per_user_limit_override"] = override
+                    except Exception:
+                        settings = {"per_user_limit_override": None}
+                    return settings, _limit_info_md(settings)
+
+                def admin_refresh():
+                    return _summarize_metrics_md()
+
+                # Wire admin interactions
+                set_override_btn.click(
+                    admin_set_limit,
+                    inputs=[override_tb, admin_state],
+                    outputs=[admin_state, admin_limit_info],
+                )
+                refresh_btn.click(admin_refresh, outputs=[admin_summary])
+
+    # Gate admin panel visibility on load (OAuth)
+    try:
+        app.load(show_admin, outputs=[admin_panel, locked_panel, admin_summary, admin_limit_info])
+    except Exception:
+        # If OAuth not available, keep admin hidden
+        pass
+
+    # Enable queue for Spaces / ZeroGPU compatibility
+    return app.queue()
+
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+# Launch the app
+if __name__ == "__main__":
+    app = create_app(language='en')
+    app.launch(share=False, show_error=True, show_api=False)

cbt_knowledge/__init__.py

@@ -0,0 +1,17 @@
+"""
+CBT Knowledge Base Module
+
+Contains cognitive distortions, reframing strategies, and therapeutic principles.
+"""
+
+from .distortions import COGNITIVE_DISTORTIONS, detect_distortions, get_distortion_by_code
+from .reframing_tools import (
+    find_similar_situations,
+)
+
+__all__ = [
+    'COGNITIVE_DISTORTIONS',
+    'get_distortion_by_code',
+    'detect_distortions',
+    'find_similar_situations',
+]

cbt_knowledge/distortions.py

@@ -0,0 +1,328 @@
+"""
+Cognitive Distortions Database
+
+Complete taxonomy of cognitive distortions with definitions, examples, and reframing strategies.
+"""
+
+from typing import Any
+
+COGNITIVE_DISTORTIONS = {
+    "mind_reading": {
+        "code": "MW",
+        "name": "Mind Reading",
+        "definition": "Assuming you know what others are thinking without evidence",
+        "examples": [
+            "They think I'm incompetent",
+            "Everyone can see how anxious I am",
+            "She must think I'm boring",
+        ],
+        "reframing_strategies": [
+            "What evidence do I have for what they're thinking?",
+            "What else might they be thinking?",
+            "How could I find out what they actually think?",
+        ],
+        "micro_actions": [
+            "Ask one person directly about their thoughts",
+            "Notice when predictions about others' thoughts were wrong",
+        ],
+    },
+    "fortune_telling": {
+        "code": "FT",
+        "name": "Fortune Telling",
+        "definition": "Predicting the future negatively as if it's certain",
+        "examples": [
+            "I'll definitely fail the interview",
+            "Things will never get better",
+            "This relationship is doomed to fail",
+        ],
+        "reframing_strategies": [
+            "What are other possible outcomes?",
+            "What's the most likely outcome based on past experience?",
+            "How certain am I really about this prediction?",
+        ],
+        "micro_actions": [
+            "Write down 3 alternative outcomes",
+            "Track prediction accuracy for one week",
+        ],
+    },
+    "catastrophizing": {
+        "code": "CT",
+        "name": "Catastrophizing",
+        "definition": "Blowing things out of proportion or imagining worst-case scenarios",
+        "examples": [
+            "This mistake will ruin my entire career",
+            "If I panic, I'll completely lose control",
+            "One bad grade means I'll never succeed",
+        ],
+        "reframing_strategies": [
+            "What's the worst, best, and most likely outcome?",
+            "How have I coped with difficulties before?",
+            "Will this matter in 5 years?",
+        ],
+        "micro_actions": [
+            "List past situations you successfully coped with",
+            "Rate actual vs predicted severity of one worry",
+        ],
+    },
+    "all_or_nothing": {
+        "code": "AO",
+        "name": "All-or-Nothing Thinking",
+        "definition": "Seeing things in black-and-white categories with no middle ground",
+        "examples": [
+            "If I'm not perfect, I'm a failure",
+            "Either they love me or they hate me",
+            "If I can't do it all, I shouldn't do any of it",
+        ],
+        "reframing_strategies": [
+            "What would the middle ground look like?",
+            "Can I rate this on a scale of 0-100?",
+            "What are the shades of gray here?",
+        ],
+        "micro_actions": [
+            "Rate one achievement on a 0-100 scale",
+            "Find 3 partial successes in your day",
+        ],
+    },
+    "mental_filter": {
+        "code": "MF",
+        "name": "Mental Filter",
+        "definition": "Focusing exclusively on negatives while filtering out positives",
+        "examples": [
+            "The whole presentation was terrible (despite mostly positive feedback)",
+            "My day was ruined (one bad thing among many good)",
+            "All I can think about is that one criticism",
+        ],
+        "reframing_strategies": [
+            "What positive aspects am I overlooking?",
+            "What would a balanced view include?",
+            "What went well, even if small?",
+        ],
+        "micro_actions": [
+            "Write 3 good things that happened today",
+            "Ask someone else what went well",
+        ],
+    },
+    "personalization": {
+        "code": "PR",
+        "name": "Personalization",
+        "definition": "Blaming yourself for things outside your control",
+        "examples": [
+            "It's my fault they're in a bad mood",
+            "The team failed because of me",
+            "If I had done better, this wouldn't have happened",
+        ],
+        "reframing_strategies": [
+            "What other factors contributed?",
+            "What was actually within my control?",
+            "Would I blame a friend this much?",
+        ],
+        "micro_actions": [
+            "Create a responsibility pie chart",
+            "List factors outside your control",
+        ],
+    },
+    "labeling": {
+        "code": "LB",
+        "name": "Labeling",
+        "definition": "Attaching global negative labels based on single instances",
+        "examples": ["I'm a loser", "They're completely selfish", "I'm such an idiot"],
+        "reframing_strategies": [
+            "What specific behavior am I reacting to?",
+            "Does one action define a whole person?",
+            "What evidence contradicts this label?",
+        ],
+        "micro_actions": [
+            "Replace one label with specific behavior description",
+            "List 3 qualities that contradict the label",
+        ],
+    },
+    "should_statements": {
+        "code": "SH",
+        "name": "Should Statements",
+        "definition": "Rigid rules about how things must be, leading to guilt or frustration",
+        "examples": [
+            "I should always be productive",
+            "They should understand without me explaining",
+            "I must never make mistakes",
+        ],
+        "reframing_strategies": [
+            "What would I prefer instead of 'should'?",
+            "Where did this rule come from?",
+            "What happens if this 'should' isn't met?",
+        ],
+        "micro_actions": [
+            "Replace 'should' with 'would like to'",
+            "Question one 'should' rule's origin",
+        ],
+    },
+    "emotional_reasoning": {
+        "code": "ER",
+        "name": "Emotional Reasoning",
+        "definition": "Believing something is true because it feels true",
+        "examples": [
+            "I feel worthless, so I must be worthless",
+            "I feel anxious, so there must be danger",
+            "I feel guilty, so I must have done something wrong",
+        ],
+        "reframing_strategies": [
+            "What are the facts separate from feelings?",
+            "Have my feelings been wrong before?",
+            "What would I tell a friend feeling this way?",
+        ],
+        "micro_actions": [
+            "List facts vs feelings about one situation",
+            "Notice when feelings didn't match reality",
+        ],
+    },
+    "discounting_positives": {
+        "code": "DP",
+        "name": "Discounting Positives",
+        "definition": "Dismissing positive experiences or achievements as not counting",
+        "examples": [
+            "They only complimented me to be nice",
+            "I only succeeded because it was easy",
+            "Anyone could have done what I did",
+        ],
+        "reframing_strategies": [
+            "What would it mean to fully accept this positive?",
+            "How do I explain others' successes?",
+            "What effort did I actually put in?",
+        ],
+        "micro_actions": [
+            "Accept one compliment at face value",
+            "Write down your role in one success",
+        ],
+    },
+    "jumping_to_conclusions": {
+        "code": "JC",
+        "name": "Jumping to Conclusions",
+        "definition": "Making negative assumptions without sufficient evidence",
+        "examples": [
+            "They didn't text back, they must hate me",
+            "I made one mistake, I'll be fired",
+            "They looked away, they must be bored",
+        ],
+        "reframing_strategies": [
+            "What evidence do I have for this conclusion?",
+            "What are other possible explanations?",
+            "Am I confusing possibility with probability?",
+        ],
+        "micro_actions": [
+            "List 3 alternative explanations",
+            "Test one assumption by asking directly",
+        ],
+    },
+    "magnification_minimization": {
+        "code": "MM",
+        "name": "Magnification/Minimization",
+        "definition": "Exaggerating negatives or minimizing positives disproportionately",
+        "examples": [
+            "This tiny mistake ruins everything",
+            "My achievements don't really count",
+            "Their small flaw makes them terrible",
+        ],
+        "reframing_strategies": [
+            "How would an outside observer rate this?",
+            "Am I using a double standard?",
+            "What's the actual size/importance of this?",
+        ],
+        "micro_actions": [
+            "Rate importance on 1-10 scale",
+            "Ask someone else for perspective",
+        ],
+    },
+    "overgeneralization": {
+        "code": "OG",
+        "name": "Overgeneralization",
+        "definition": "Making broad conclusions from single events",
+        "examples": [
+            "I failed once, I always fail",
+            "One person rejected me, nobody likes me",
+            "This always happens to me",
+        ],
+        "reframing_strategies": [
+            "Is this always true, or just sometimes?",
+            "What are the exceptions to this pattern?",
+            "Am I using words like 'always' or 'never' accurately?",
+        ],
+        "micro_actions": [
+            "Find 3 exceptions to the pattern",
+            "Replace 'always/never' with 'sometimes'",
+        ],
+    },
+}
+
+
+def get_distortion_by_code(code: str) -> dict[str, Any] | None:
+    """Get distortion details by its code."""
+    for distortion in COGNITIVE_DISTORTIONS.values():
+        if distortion["code"] == code:
+            return distortion
+    return None
+
+
+def detect_distortions(thought_text: str) -> list:
+    """
+    Analyze text for potential cognitive distortions.
+    Returns list of likely distortion codes with confidence scores.
+    """
+    thought_lower = thought_text.lower()
+    detected = []
+
+    # All-or-nothing thinking
+    if any(
+        word in thought_lower
+        for word in [
+            "always",
+            "never",
+            "everyone",
+            "everything",
+            "none",
+            "nothing",
+            "completely",
+            "totally",
+        ]
+    ):
+        detected.append(("AO", 0.8))
+
+    # Fortune telling
+    future_words = ["will", "going to", "definitely", "won't", "can't", "surely"]
+    negative_outcomes = ["fail", "disaster", "terrible", "awful", "ruin", "mess up"]
+    if any(word in thought_lower for word in future_words) and any(
+        neg in thought_lower for neg in negative_outcomes
+    ):
+        detected.append(("FT", 0.7))
+
+    # Should statements
+    if any(word in thought_lower for word in ["should", "must", "have to", "ought", "need to"]):
+        detected.append(("SH", 0.9))
+
+    # Labeling
+    if "i am" in thought_lower or "i'm" in thought_lower or "im " in thought_lower:
+        labels = ["stupid", "loser", "failure", "worthless", "idiot", "incompetent", "pathetic"]
+        if any(label in thought_lower for label in labels):
+            detected.append(("LB", 0.9))
+
+    # Mind reading
+    if any(
+        phrase in thought_lower
+        for phrase in ["they think", "he thinks", "she thinks", "everyone thinks", "people think"]
+    ):
+        detected.append(("MW", 0.7))
+
+    # Catastrophizing
+    if any(
+        word in thought_lower
+        for word in ["disaster", "catastrophe", "ruin", "destroy", "horrible", "terrible", "worst"]
+    ):
+        detected.append(("CT", 0.8))
+
+    # Emotional reasoning
+    if "i feel" in thought_lower and any(
+        word in thought_lower for word in ["so i must", "therefore", "that means"]
+    ):
+        detected.append(("ER", 0.6))
+
+    # Sort by confidence and return
+    detected.sort(key=lambda x: x[1], reverse=True)
+    return detected

cbt_knowledge/reframing_tools.py

@@ -0,0 +1,201 @@
+"""
+Reframing Tools and Strategies
+
+Functions for generating reframes, finding similar situations, and suggesting micro-actions.
+"""
+
+import random
+
+
+def find_similar_situations(distortion_code: str, num_situations: int = 3) -> list[dict]:
+    """
+    Find similar situations that involve the same cognitive distortion.
+
+    Args:
+        distortion_code: The cognitive distortion code
+        num_situations: Number of situations to return
+
+    Returns:
+        List of similar situation examples with reframes
+    """
+    # Database of example situations for each distortion
+    situation_database = {
+        "AO": [
+            {
+                "situation": "Missing one deadline at work",
+                "distorted": "I'm a complete failure at my job",
+                "reframed": (
+                    "I missed one deadline, but I've met many others. I can learn from this and "
+                    "improve my time management."
+                ),
+            },
+            {
+                "situation": "Friend cancels plans",
+                "distorted": "They hate me and never want to see me",
+                "reframed": (
+                    "They cancelled once, which could be for many reasons. Our friendship has many "
+                    "positive moments."
+                ),
+            },
+            {
+                "situation": "Making a mistake in presentation",
+                "distorted": "The entire presentation was a disaster",
+                "reframed": (
+                    "I made one error, but conveyed most information well. The audience was still "
+                    "engaged."
+                ),
+            },
+        ],
+        "FT": [
+            {
+                "situation": "Job interview tomorrow",
+                "distorted": "I'll definitely mess up and embarrass myself",
+                "reframed": (
+                    "Interviews can go many ways. I've prepared and have relevant experience to "
+                    "share."
+                ),
+            },
+            {
+                "situation": "Starting a new project",
+                "distorted": "This will never work out",
+                "reframed": (
+                    "New projects have challenges and possibilities. I can adapt as I learn more."
+                ),
+            },
+            {
+                "situation": "Asking someone out",
+                "distorted": "They'll definitely reject me",
+                "reframed": (
+                    "They might say yes or no. Either way, I'm brave for trying and will "
+                    "learn from it."
+                ),
+            },
+        ],
+        "CT": [
+            {
+                "situation": "Making a typo in an email",
+                "distorted": "This will ruin my professional reputation forever",
+                "reframed": (
+                    "It's a small error that most people understand. My work quality speaks louder "
+                    "than one typo."
+                ),
+            },
+            {
+                "situation": "Feeling anxious at a party",
+                "distorted": "I'll have a panic attack and everyone will think I'm crazy",
+                "reframed": (
+                    "I feel anxious, which is uncomfortable but manageable. I can take breaks if "
+                    "needed."
+                ),
+            },
+            {
+                "situation": "Child struggles in one subject",
+                "distorted": "They'll never succeed in life",
+                "reframed": (
+                    "They're having difficulty in one area while doing well in others. We can get "
+                    "help for this specific challenge."
+                ),
+            },
+        ],
+        "SH": [
+            {
+                "situation": "Taking a rest day",
+                "distorted": "I should always be productive",
+                "reframed": (
+                    "I'd like to be productive, and rest is part of sustainable productivity."
+                ),
+            },
+            {
+                "situation": "Asking for help",
+                "distorted": "I should handle everything myself",
+                "reframed": "I prefer independence, and asking for help when needed is a strength.",
+            },
+            {
+                "situation": "Making a parenting mistake",
+                "distorted": "I should be a perfect parent",
+                "reframed": (
+                    "I aim to be a good parent, and making mistakes is part of learning and "
+                    "growing."
+                ),
+            },
+        ],
+        "MW": [
+            {
+                "situation": "Boss seems quiet",
+                "distorted": "They think I'm doing a bad job",
+                "reframed": (
+                    "They seem quiet, which could mean many things - "
+                    "busy, tired, or thinking about something else."
+                ),
+            },
+            {
+                "situation": "People laughing nearby",
+                "distorted": "They're laughing at me",
+                "reframed": (
+                    "People are laughing, likely about their own conversation. I don't have "
+                    "evidence it's about me."
+                ),
+            },
+            {
+                "situation": "Partner is distant",
+                "distorted": "They're losing interest in me",
+                "reframed": (
+                    "They seem distant today. They might be stressed about something. I could ask "
+                    "how they're doing."
+                ),
+            },
+        ],
+        "LB": [
+            {
+                "situation": "Failed at a task",
+                "distorted": "I'm such a loser",
+                "reframed": (
+                    "I struggled with this specific task. It doesn't define my worth as a person."
+                ),
+            },
+            {
+                "situation": "Someone was rude",
+                "distorted": "They're a horrible person",
+                "reframed": (
+                    "They acted rudely in this moment. People are complex and have good and bad "
+                    "moments."
+                ),
+            },
+            {
+                "situation": "Made a social mistake",
+                "distorted": "I'm so awkward and weird",
+                "reframed": (
+                    "I had an awkward moment, which happens to everyone. It's one small part of "
+                    "who I am."
+                ),
+            },
+        ],
+    }
+
+    # Get situations for this distortion, or return generic ones
+    situations = situation_database.get(distortion_code, [])
+
+    if not situations:
+        # Return generic situations if specific ones not found
+        situations = [
+            {
+                "situation": "Challenging work situation",
+                "distorted": "Everything is going wrong",
+                "reframed": "This situation has both challenges and manageable aspects.",
+            },
+            {
+                "situation": "Social interaction difficulty",
+                "distorted": "I always mess up socially",
+                "reframed": "I had one difficult interaction among many neutral or positive ones.",
+            },
+            {
+                "situation": "Personal setback",
+                "distorted": "I'll never recover from this",
+                "reframed": "This is a setback I can learn from and gradually move past.",
+            },
+        ]
+
+    # Return requested number of situations (random selection if more available)
+    if len(situations) > num_situations:
+        return random.sample(situations, num_situations)
+    return situations

locales/en.json

@@ -0,0 +1,39 @@
+{
+  "app_title": "🧠 re-frame: Cognitive Reframing Assistant",
+  "app_description": "Using CBT principles to help you find balanced perspectives",
+  "welcome": {
+    "title": "Welcome",
+    "subtitle": "Find a kinder perspective",
+    "description": "Using ideas from Cognitive Behavioral Therapy (CBT), we help you notice thinking patterns and explore gentler, more balanced perspectives. You choose what fits.",
+    "how_it_works": "How it works",
+    "step1": "Share your thoughts",
+    "step1_desc": "Tell us what's on your mind - short is fine",
+    "step2": "Notice patterns",
+    "step2_desc": "We'll help identify thinking traps",
+    "step3": "Find balance",
+    "step3_desc": "Explore alternative perspectives that feel true",
+    "start_chat": "Start Chat",
+    "disclaimer": "Important: This is a self-help tool using CBT ideas. It is not psychotherapy, medical advice, or a crisis service.",
+    "privacy": "Privacy: We don't store any data beyond your current session."
+  },
+  "chat": {
+    "title": "Chat",
+    "placeholder": "Share what's on your mind...",
+    "send": "Send",
+    "clear": "New Session",
+    "thinking": "Thinking...",
+    "distortions_found": "Thinking patterns identified:",
+    "reframe_suggestion": "Alternative perspective:",
+    "similar_situations": "Similar situations others have reframed:",
+    "try_this": "You might try:",
+    "no_distortions": "Let me understand better. Can you tell me more about the specific thoughts going through your mind?"
+  },
+  "learn": {
+    "title": "Learn",
+    "select_distortion": "Select a thinking pattern to explore",
+    "definition": "What it is",
+    "examples": "Common Examples",
+    "strategies": "Questions to Consider",
+    "actions": "Small Steps to Try"
+  }
+}

locales/es.json

@@ -0,0 +1,39 @@
+{
+  "app_title": "🧠 re-frame: Asistente de Reencuadre Cognitivo",
+  "app_description": "Usando principios de TCC para ayudarte a encontrar perspectivas equilibradas",
+  "welcome": {
+    "title": "Bienvenido",
+    "subtitle": "Encuentra una perspectiva más amable",
+    "description": "Usando ideas de la Terapia Cognitivo-Conductual (TCC), te ayudamos a notar patrones de pensamiento y explorar perspectivas más gentiles y equilibradas. Tú eliges lo que te sirva.",
+    "how_it_works": "Cómo funciona",
+    "step1": "Comparte tus pensamientos",
+    "step1_desc": "Cuéntanos qué piensas - breve también está bien",
+    "step2": "Detecta patrones",
+    "step2_desc": "Te ayudamos a identificar trampas mentales",
+    "step3": "Encuentra balance",
+    "step3_desc": "Explora perspectivas alternativas que se sientan verdaderas",
+    "start_chat": "Iniciar Chat",
+    "disclaimer": "Importante: Esta es una herramienta de autoayuda que usa ideas de TCC. No es psicoterapia, consejo médico, ni un servicio de crisis.",
+    "privacy": "Privacidad: No almacenamos datos más allá de tu sesión actual."
+  },
+  "chat": {
+    "title": "Chat",
+    "placeholder": "Comparte lo que piensas...",
+    "send": "Enviar",
+    "clear": "Nueva Sesión",
+    "thinking": "Pensando...",
+    "distortions_found": "Patrones de pensamiento identificados:",
+    "reframe_suggestion": "Perspectiva alternativa:",
+    "similar_situations": "Situaciones similares que otros han reencuadrado:",
+    "try_this": "Podrías intentar:",
+    "no_distortions": "Déjame entender mejor. ¿Puedes contarme más sobre los pensamientos específicos que pasan por tu mente?"
+  },
+  "learn": {
+    "title": "Aprender",
+    "select_distortion": "Selecciona un patrón de pensamiento para explorar",
+    "definition": "Qué es",
+    "examples": "Ejemplos Comunes",
+    "strategies": "Preguntas a Considerar",
+    "actions": "Pequeños Pasos a Intentar"
+  }
+}

mypy.ini

@@ -0,0 +1,20 @@
+[mypy]
+python_version = 3.10
+ignore_missing_imports = True
+warn_unused_ignores = True
+warn_redundant_casts = True
+warn_unreachable = True
+strict_optional = True
+check_untyped_defs = True
+exclude = ^reframe\.egg-info/|^build/|^dist/|^\.venv/
+mypy_path = .
+namespace_packages = True
+explicit_package_bases = True
+
+# Keep typing strictness reasonable for this project
+disallow_untyped_defs = False
+disallow_any_generics = False
+
+# Don’t type-check tests strictly
+[mypy-tests.*]
+ignore_errors = True

requirements-dev.txt

@@ -0,0 +1,4 @@
+pytest>=7.0
+ruff>=0.5.0
+mypy>=1.8.0
+-e .

requirements.txt

@@ -0,0 +1,21 @@
+# Core dependencies for re-frame Gradio app (pinned for Spaces reproducibility)
+gradio==5.47.2
+
+# Use a recent hub client for streaming + MCP client support
+huggingface-hub==0.35.1
+
+# smolagents removed: not used in this Space
+transformers==4.56.2
+
+# For using HuggingFace inference API
+accelerate==1.10.1
+sentencepiece==0.2.1
+protobuf==6.32.1
+
+# Optional: For local model support
+# If you plan to run local models inside the Space, uncomment torch.
+# torch==2.8.0
+
+# Utility libraries
+python-dotenv==1.1.1
+typing-extensions==4.15.0

ruff.toml

@@ -0,0 +1,12 @@
+line-length = 100
+target-version = "py310"
+
+[lint]
+select = ["E", "F", "I", "B", "UP"]
+ignore = []
+
+[format]
+quote-style = "preserve"
+indent-style = "space"
+line-ending = "lf"
+

setup.cfg

@@ -0,0 +1,16 @@
+[metadata]
+name = reframe
+version = 0.0.0
+description = Cognitive Reframing Tool
+long_description = file: README.md
+long_description_content_type = text/markdown
+license = MIT
+
+[options]
+packages = find:
+include_package_data = True
+python_requires = >=3.10
+
+[options.packages.find]
+where = .
+

setup.py

@@ -0,0 +1,4 @@
+from setuptools import setup
+
+if __name__ == "__main__":
+    setup()

tests/test_agent.py

@@ -0,0 +1,28 @@
+import os
+
+import pytest
+
+from agents import CBTAgent
+
+requires_hf_token = pytest.mark.skipif(
+    not (os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN")),
+    reason="HF Inference token not configured",
+)
+
+
+@requires_hf_token
+def test_agent_analyze_thought_with_hf():
+    agent = CBTAgent()
+    analysis = agent.analyze_thought("I will fail the interview")
+    assert isinstance(analysis, dict)
+    codes = [c for c, _ in analysis.get("distortions", [])]
+    assert "FT" in codes
+    assert isinstance(analysis.get("reframe", ""), str) and analysis["reframe"]
+    assert isinstance(analysis.get("similar_situations", []), list)
+
+
+@requires_hf_token
+def test_agent_generate_response_hf():
+    agent = CBTAgent()
+    resp = agent.generate_response("I will definitely mess up the interview")
+    assert isinstance(resp, str) and len(resp) > 0

tests/test_distortions.py

@@ -0,0 +1,25 @@
+from cbt_knowledge import detect_distortions
+
+
+def codes(text: str):
+    return {c for c, _ in detect_distortions(text)}
+
+
+def test_detect_all_or_nothing():
+    assert "AO" in codes("I always fail; nothing works")
+
+
+def test_detect_fortune_telling():
+    assert "FT" in codes("I will fail the interview")
+
+
+def test_detect_should_statements():
+    assert "SH" in codes("I should always be productive")
+
+
+def test_detect_labeling():
+    assert "LB" in codes("I'm such an idiot")
+
+
+def test_no_false_positive_on_neutral_text():
+    assert detect_distortions("I went to the park and had a nice day.") == []

tests/test_reframing_tools.py

@@ -0,0 +1,8 @@
+from cbt_knowledge import find_similar_situations
+
+
+def test_find_similar_situations_returns_shape():
+    items = find_similar_situations("AO", num_situations=2)
+    assert isinstance(items, list) and len(items) == 2
+    for it in items:
+        assert set(["situation", "distorted", "reframed"]).issubset(it.keys())

ui_components/__init__.py

@@ -0,0 +1,8 @@
+"""
+UI Components for re-frame Gradio app
+"""
+
+from .landing import create_landing_tab
+from .learn import create_learn_tab
+
+__all__ = ['create_landing_tab', 'create_learn_tab']

ui_components/landing.py

@@ -0,0 +1,42 @@
+"""
+Landing page component for re-frame
+"""
+
+import gradio as gr
+
+
+def create_landing_tab(translations):
+    """Create the landing/welcome tab content"""
+
+    with gr.Column():
+        # Hero section
+        gr.Markdown(f"## {translations['subtitle']}")
+        gr.Markdown(translations['description'])
+
+        # How it works section
+        gr.Markdown(f"### {translations['how_it_works']}")
+
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown(f"**1. {translations['step1']}**")
+                gr.Markdown(translations['step1_desc'])
+
+            with gr.Column():
+                gr.Markdown(f"**2. {translations['step2']}**")
+                gr.Markdown(translations['step2_desc'])
+
+            with gr.Column():
+                gr.Markdown(f"**3. {translations['step3']}**")
+                gr.Markdown(translations['step3_desc'])
+
+        # Disclaimer
+        with gr.Row():
+            gr.Markdown(f"ℹ️ **{translations['disclaimer']}**")
+
+        with gr.Row():
+            gr.Markdown(f"🔒 **{translations['privacy']}**")
+
+        # Call to action
+        gr.Markdown("---")
+        gr.Markdown("### Ready to start?")
+        gr.Markdown("Navigate to the **Chat** tab above to begin your session.")

ui_components/learn.py

@@ -0,0 +1,62 @@
+"""
+Learn tab component for exploring cognitive distortions
+"""
+
+import gradio as gr
+
+
+def create_learn_tab(translations, distortions_db):
+    """Create the learn/education tab"""
+
+    with gr.Column():
+        gr.Markdown("### Explore Cognitive Distortions")
+        gr.Markdown("Learn about common thinking patterns and how to work with them.")
+
+        # Dropdown to select distortion
+        distortion_names = [info['name'] for info in distortions_db.values()]
+        selected = gr.Dropdown(
+            choices=distortion_names,
+            label=translations['select_distortion'],
+            value=distortion_names[0] if distortion_names else None,
+        )
+
+        # Display area for distortion information
+        with gr.Column():
+            definition_display = gr.Markdown()
+            examples_display = gr.Markdown()
+            strategies_display = gr.Markdown()
+            actions_display = gr.Markdown()
+
+        def show_distortion_info(distortion_name):
+            """Display information about selected distortion"""
+            # Find the distortion by name
+            for _key, info in distortions_db.items():
+                if info['name'] == distortion_name:
+                    definition = f"### {translations['definition']}\n{info['definition']}"
+
+                    examples = f"### {translations['examples']}\n"
+                    for example in info['examples']:
+                        examples += f"- \"{example}\"\n"
+
+                    strategies = f"### {translations['strategies']}\n"
+                    for strategy in info['reframing_strategies']:
+                        strategies += f"- {strategy}\n"
+
+                    actions = f"### {translations['actions']}\n"
+                    for action in info['micro_actions']:
+                        actions += f"- {action}\n"
+
+                    return definition, examples, strategies, actions
+
+            return "", "", "", ""
+
+        # Connect dropdown to display
+        selected.change(
+            show_distortion_info,
+            inputs=[selected],
+            outputs=[definition_display, examples_display, strategies_display, actions_display],
+        )
+
+        # Initialize with first distortion
+        if distortion_names:
+            selected.value = distortion_names[0]