Blame for app.py

import logging
import os
from hashlib import sha256
import gradio as gr
from huggingface_hub import InferenceClient
from openai import OpenAI
from engine.chat import generate_response
from engine.memory import load_conversation, sync_history
from engine.persona import get_empty_persona, is_persona_empty, persona_summary, validate_persona
from engine.prompt_builder import get_avatar_path, load_character, list_characters
from engine.saveload import export_save, import_save, restore_save
from engine.suggestions import generate_suggestions
from engine.memory_controls import change_memory, set_relationship_options, context_messages
from engine.relationship import relationship_descriptions, get_default_relationship

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# ── Configuration ──────────────────────────────────────────────────────────────
# Switch DEFAULT_CHARACTER to load a different character from characters/*.json
# Switch MODEL to change the LLM (any model available on HuggingFace Inference API)
DEFAULT_CHARACTER = "hermione_granger"

MODELS = [
    ("DeepSeek V3",                         "deepseek-ai/DeepSeek-V3"),
    ("GPT-4o Mini",                         "openai/gpt-4o-mini"),
    ("GPT-OSS",                             "openai/gpt-oss-120b"),
    ("GLM-4.5",                             "zai-org/GLM-4.5"),
    ("Gemma-3 27B",                         "google/gemma-3-27b-it"),
    ("Mistral 7B Instruct",                 "mistralai/Mistral-7B-Instruct-v0.3"),
    ("Mistral Small 3.2 24B Instruct",      "mistralai/Mistral-Small-3.2-24B-Instruct-2506"),
    ("Llama 3.3 70B Instruct",              "meta-llama/Llama-3.3-70B-Instruct"),
    ("Llama 3.1 8B Instruct",               "meta-llama/Llama-3.1-8B-Instruct"),
    ("Hermes 3 Llama 3.1 8B",               "NousResearch/Hermes-3-Llama-3.1-8B"),
    ("Qwen 2.5 72B Instruct",               "Qwen/Qwen2.5-72B-Instruct"),
    ("Qwen 2.5 14B Instruct",               "Qwen/Qwen2.5-14B-Instruct"),
    ("Qwen 3 32 B",                         "Qwen/Qwen3-32B"),
    ("Qwen 3 30B Instruct",                 "Qwen/Qwen3-30B-A3B-Instruct-2507"),
    ("Qwen 3 235B Instruct",                "Qwen/Qwen3-235B-A22B-Instruct-2507"),
    ("Qwen3.8 27B OBLITERATED",            "OBLITERATUS/Qwen3.8-27B-OBLITERATED:featherless-ai"),
    ("Huihui CyberStrike OffSec 35B",       "huihui-ai/Huihui-CyberStrike-OffSec-35B-abliterated:featherless-ai"),
    ("Gemma 4 E4B OBLITERATED",            "OBLITERATUS/gemma-4-E4B-it-OBLITERATED:featherless-ai"),
    ("Qwen 3 32B abliterated",              "huihui-ai/Qwen3-32B-abliterated:featherless-ai"),
    ("Mistral Nemo 12B HERETIC",            "DavidAU/Mistral-Nemo-2407-12B-Thinking-Claude-Gemini-GPT5.2-Uncensored-HERETIC:featherless-ai"),
    ("Gemma 4 26B A4B uncensored",          "TrevorJS/gemma-4-26B-A4B-it-uncensored:featherless-ai"),
    ("Qwen3.8 9B Distill uncensored",        "petruhonk/Qwen3.8-9B-Distill-uncensored-heretic:featherless-ai"),
    ("Wizard Vicuna 7B Uncensored",         "QuixiAI/Wizard-Vicuna-7B-Uncensored:featherless-ai"),
    ("Llama 3 70B abliterated",             "failspy/llama-3-70B-Instruct-abliterated:featherless-ai"),
    ("Llama 3 8B abliterated v3",           "failspy/Meta-Llama-3-8B-Instruct-abliterated-v3:featherless-ai"),
    ("Llama 3.1 8B abliterated",            "mlabonne/Meta-Llama-3.1-8B-Instruct-abliterated:featherless-ai"),
    ("Qwen 2.5 7B abliterated v2",          "huihui-ai/Qwen2.5-7B-Instruct-abliterated-v2:featherless-ai"),
    ("Qwen 2.5 72B abliterated",            "huihui-ai/Qwen2.5-72B-Instruct-abliterated:featherless-ai"),
    ("Llama 3.3 8B Thinking HERETIC",       "DavidAU/Llama3.3-8B-Instruct-Thinking-Heretic-Uncensored-Claude-4.5-Opus-High-Reasoning:featherless-ai"),
    ("Qwen 3.5 9B abliterated",             "wangzhang/Qwen3.5-9B-abliterated:featherless-ai"),
    ("Qwen3.8 27B AEON Ultimate",           "AEON-7/Qwen3.8-27B-AEON-ULTIMATE-UNCENSORED-BF16:featherless-ai"),
    ("NeuralDaredevil 8B abliterated",      "mlabonne/NeuralDaredevil-8B-abliterated:featherless-ai"),
    ("Llama 3 70B abliterated v3.5",        "failspy/Meta-Llama-3-70B-Instruct-abliterated-v3.5:featherless-ai"),
    ("Qwen 2.5 7B Uncensored",              "Orion-zhen/Qwen2.5-7B-Instruct-Uncensored:featherless-ai"),
    ("Llama 3.3 70B abliterated",           "huihui-ai/Llama-3.3-70B-Instruct-abliterated:featherless-ai"),
    ("DeepSeek R1 Distill Qwen 14B abliterated", "huihui-ai/DeepSeek-R1-Distill-Qwen-14B-abliterated-v2:featherless-ai"),
    ("Qwen 3 8B abliterated",               "mlabonne/Qwen3-8B-abliterated:featherless-ai"),
    ("Huihui Qwen 3 14B abliterated v2",    "huihui-ai/Huihui-Qwen3-14B-abliterated-v2:featherless-ai"),
    ("Huihui Qwen 3 8B abliterated v2",     "huihui-ai/Huihui-Qwen3-8B-abliterated-v2:featherless-ai"),
    ("Josiefied Qwen 3 4B gabliterated v2", "Goekdeniz-Guelmez/Josiefied-Qwen3-4B-Instruct-2507-gabliterated-v2:featherless-ai"),
    ("Qwen 3 0.6B HERETIC",                 "DavidAU/Qwen3-0.6B-heretic-abliterated-uncensored:featherless-ai"),
    ("Qwen 3.5 27B Derestricted",           "ArliAI/Qwen3.5-27B-Derestricted:featherless-ai"),
    ("Loki V2 HERETIC Uncensored",          "hackoffice/Loki-V2.0-Heretic-Uncensored:featherless-ai"),
    ("Gemma 4 12B uncensored",              "TrevorJS/gemma-4-12B-it-uncensored:featherless-ai"),
    ("Gemma 4 12B Coder uncensored HERETIC", "llmfan46/gemma-4-12B-coder-fable5-composer2.5-v1-uncensored-heretic:featherless-ai"),
    ("Huihui Qwythos 9B abliterated",        "huihui-ai/Huihui-Qwythos-9B-Claude-Mythos-5-1M-abliterated:featherless-ai"),
    ("Llama 3.1 Dark Reasoning HERETIC 8B", "DavidAU/L3.1-Dark-Reasoning-LewdPlay-evo-Hermes-R1-Uncensored-8B:featherless-ai"),
    ("DAN L3 R1 8B",                        "UnfilteredAI/DAN-L3-R1-8B:featherless-ai"),
]

LANGUAGES = ["English", "French", "German", "Italian", "Russian", "Turkish", "Chinese"]

DEFAULT_MODEL       = MODELS[4][1]
DEFAULT_LANGUAGE    = "English"
TRANSLATION_MODEL   = "google/gemma-3-27b-it"

#MODEL        = "deepseek-ai/DeepSeek-V3"   # or e.g. "openai/gpt-4o-mini"
#MODEL       = "Qwen/Qwen3-235B-A22B-Instruct-2507"
#MODEL       = "Qwen/Qwen3-30B-A3B-Instruct-2507"
#MODEL       = "Qwen/Qwen3-32B"
#MODEL       = "zai-org/GLM-4.5"
#MODEL       = "openai/gpt-oss-120b"
#MODEL       = "mistralai/Mistral-Small-3.2-24B-Instruct-2506"
#MODEL       = "meta-llama/Llama-3.3-70B-Instruct"
#MODEL       = "google/gemma-3-27b-it"
#MODEL       = "NousResearch/Hermes-3-Llama-3.1-8B"
#MODEL       = "Qwen/Qwen2.5-14B-Instruct"
#MODEL = "Mantis2024/Dirty-Muse-Writer-v01-Uncensored-Erotica-NSFW"

# ── HuggingFace token ──────────────────────────────────────────────────────────
# Add your token as a Space secret: Settings → Variables and secrets → New secret
# Name: HF_TOKEN  |  Value: hf_xxxxxxxxxxxxxxxx
HF_TOKEN = os.environ.get("HF_TOKEN")
if not HF_TOKEN:
    logger.warning("HF_TOKEN secret is not set. Inference calls will fail.")


def create_hf_client():
    """Return a client compatible with both the legacy HF API and HF Router."""
    return InferenceClient(token=HF_TOKEN, timeout=60)


def create_router_client():
    """Create the OpenAI-compatible client for Hugging Face's Router API."""
    return OpenAI(
        base_url="https://router.huggingface.co/v1",
        api_key=HF_TOKEN,
        timeout=60,
    )

# ── Load default character on startup ─────────────────────────────────────────
character   = load_character(DEFAULT_CHARACTER)
avatar_path = get_avatar_path(DEFAULT_CHARACTER)

char_name = character.get("name", DEFAULT_CHARACTER)
char_role = character.get("identity", {}).get("role", "")
greeting  = character.get("greeting", "Hello. What do you want?")

# ── Discover all characters for the selector ───────────────────────────────────
all_characters = list_characters()
character_by_id = {c["id"]: c for c in all_characters}
category_names = []
for item in all_characters:
    for category in item.get("categories", []):
        if category not in category_names:
            category_names.append(category)
char_choices = [
    (f"{category} / {character_by_id[character_id]['name']}", character_id)
    for category in category_names
    for character_id in (item["id"] for item in all_characters if category in item.get("categories", []))
]

# ── Session states ──────────────────────────────────────────────────────────────
persona_state        = gr.State(get_empty_persona())
char_id_state        = gr.State(DEFAULT_CHARACTER)
language_state       = gr.State(DEFAULT_LANGUAGE)
model_state          = gr.State(DEFAULT_MODEL)
use_translator_state = gr.State(False)   # True = separate translator model, False = main model handles language

# ── Gradio respond function ────────────────────────────────────────────────────

def session_key(request: gr.Request) -> str:
    if request is None or not request.session_hash:
        raise gr.Error("A browser session is required. Please reload the page.")
    return sha256(request.session_hash.encode()).hexdigest()[:32]


def persist_visible_history(history, char_id: str, request: gr.Request):
    sync_history(session_key(request), char_id, history)


def respond(
    message:        str,
    history:        list[dict],   # Gradio messages; normalized before model use
    max_tokens:     int,
    temperature:    float,
    top_p:          float,
    persona:        dict,         # gr.State — user persona, empty by default (form added in Phase 9)
    char_id:        str,
    language:       str,
    model_id:       str,
    use_translator: bool,         # True = separate translator model, False = main model handles language
    request: gr.Request,
):
    session_id = session_key(request)
    if not HF_TOKEN:
        yield "⚠️ HF_TOKEN secret is not set. Add it in Space settings and restart."
        return

    client = create_router_client() if model_id.endswith(":featherless-ai") else create_hf_client()

    # Pass persona only when at least one field is filled
    active_persona = validate_persona(persona) if persona else None
    if active_persona and is_persona_empty(active_persona):
        active_persona = None

    yield from generate_response(
        message=message,
        session_id=session_id,
        history=history,
        character_id=char_id,
        client=client,
        persona=active_persona,
        model=model_id,
        max_tokens=max_tokens,
        temperature=temperature,
        top_p=top_p,
        language=language,
        translation_model=TRANSLATION_MODEL,
        use_translator=use_translator,
    )


class SessionChatInterface(gr.ChatInterface):
    """Expose Gradio's generation dependencies so resets also cancel streaming.

    This small adapter is covered by integration tests against pinned Gradio 6.12.0.
    """
    def _setup_stop_events(self, *, event_triggers, events_to_cancel, after_success):
        self.generation_events = events_to_cancel
        super()._setup_stop_events(event_triggers=event_triggers,
                                  events_to_cancel=events_to_cancel,
                                  after_success=after_success)


# ── Event handlers ─────────────────────────────────────────────────────────────

def ui_history(history):
    # State outputs bypass component postprocessing; Gradio retry expects text blocks.
    return chatbot.chatbot.preprocess(chatbot.chatbot.postprocess(history))


def clear_chat_fn(char_id: str, request: gr.Request):
    sync_history(session_key(request), char_id, [])
    return [], [], []


def stop_chat_fn(history, char_id: str, request: gr.Request):
    persist_visible_history(history, char_id, request)
    normalized = ui_history(history)
    return normalized, normalized


def on_character_change(new_char_id: str, request: gr.Request):
    session_id = session_key(request)
    logger.info(f"[App] Character change requested → '{new_char_id}'")
    try:
        char = load_character(new_char_id)
    except Exception as e:
        logger.error(f"[App] Could not load character '{new_char_id}': {e}")
        return [gr.update()] * 7
    name   = char.get("name", new_char_id)
    role   = char.get("identity", {}).get("role", "")
    avatar = get_avatar_path(new_char_id)
    logger.info(f"[App] Character loaded: name='{name}', role='{role}', avatar={'found' if avatar else 'missing'}")
    history = load_conversation(session_id, new_char_id)["recent_messages"]
    return (
        new_char_id,
        f"## {name}",
        f"*{role}*" if role else "",
        gr.update(value=avatar, visible=avatar is not None),
        gr.update(
            value=history,
            label=name,
            avatar_images=(None, avatar),
        ),
        ui_history(history), ui_history(history),
    )


def apply_persona_fn(name, age, gender, personality, background):
    persona = validate_persona({
        "name": name, "age": age, "gender": gender,
        "personality": personality, "background": background,
    })
    if is_persona_empty(persona):
        logger.info("[App] Persona applied but all fields empty — no persona active.")
        return persona, "*No persona set.*"
    logger.info(f"[App] Persona applied: {persona_summary(persona)}")
    return persona, f"*✓ Active: {persona_summary(persona)}*"


def clear_persona_fn():
    logger.info("[App] Persona cleared.")
    # Returns: persona_state, 5 form fields, status
    return get_empty_persona(), "", "", "", "", "", "*Persona cleared.*"



def clear_suggestions_fn():
    return [gr.update(visible=False)] * 5 + [""] * 4


def get_suggestions_fn(char_id: str, model_id: str, language: str, persona: dict, request: gr.Request):
    session_id = session_key(request)
    logger.info(f"[App] Suggestion request: char='{char_id}', model='{model_id}'")
    if not HF_TOKEN:
        logger.warning("[App] Suggestions skipped — HF_TOKEN not set.")
        return [gr.update(visible=False)] + [gr.update(visible=False)] * 4 + [""] * 4
    recent = context_messages(load_conversation(session_id, char_id))[-6:]
    if not recent:
        logger.info("[App] Suggestions skipped — no recent messages.")
        return [gr.update(visible=False)] + [gr.update(visible=False)] * 4 + [""] * 4
    try:
        char   = load_character(char_id)
        client = create_router_client() if model_id.endswith(":featherless-ai") else create_hf_client()
        suggestions = generate_suggestions(char, recent, client, model_id, language=language, persona=persona)
        logger.info(f"[App] Suggestions generated: {[s['tone'] for s in suggestions]}")
    except Exception as e:
        logger.error(f"[App] Suggestion error: {e}")
        return [gr.update(visible=False)] + [gr.update(visible=False)] * 4 + [""] * 4
    return (
        [gr.update(visible=True)]
        + [gr.update(value=f"{s['emoji']}  {s['text']}", visible=True) for s in suggestions]
        + [s["text"] for s in suggestions]
    )


def save_conversation_fn(char_id: str, persona: dict, request: gr.Request):
    """Write a save file and return its path for Gradio to serve as download."""
    session_id = session_key(request)
    logger.info(f"[App] Save requested for char='{char_id}'")
    try:
        path = export_save(char_id, persona, session_id)
        logger.info(f"[App] Save successful → {path}")
        name = load_character(char_id).get("name", char_id)
        return gr.update(value=path, visible=True), f"*✓ Save file ready for {name} — click to download.*"
    except Exception as e:
        logger.error(f"[App] Save failed: {e}", exc_info=True)
        return gr.update(visible=False), f"*❌ Save failed: {e}*"


def invalidate_save_fn():
    """A download is a snapshot; hide it once the conversation context changes."""
    return gr.update(value=None, visible=False), ""


def load_conversation_fn(file_path, current_char_id: str, request: gr.Request):
    """
    Read an uploaded save file, restore memory, and refresh the UI.

    Outputs (15):
        char_id_state, persona_state,
        p_name, p_age, p_gender, p_personality, p_background,
        chatbot.chatbot,
        name_md, role_md, avatar_img, char_selector,
        load_status
    """
    session_id = session_key(request)
    no_op = [gr.update()] * 14 + [""]

    if not file_path:
        logger.debug("[App] Load called with no file path — skipping.")
        return no_op

    logger.info(f"[App] Load requested: {file_path}")
    try:
        data = import_save(file_path)
        data = restore_save(data, session_id)
    except (ValueError, KeyError) as e:
        logger.warning(f"[App] Load validation error: {e}")
        return no_op[:-1] + [f"*❌ {e}*"]
    except Exception as e:
        logger.error(f"[App] Load error: {e}", exc_info=True)
        return no_op[:-1] + [f"*❌ Unexpected error: {type(e).__name__}*"]

    char_id = data["character_id"]
    persona = validate_persona(data.get("persona", {}))
    recent  = data.get("conversation", {}).get("recent_messages", [])

    char = load_character(char_id)

    name   = char.get("name", char_id)
    role   = char.get("identity", {}).get("role", "")
    avatar = get_avatar_path(char_id)

    # Restore the complete transcript, including the state used by retry/undo.
    history = recent

    return (
        char_id,                                       # char_id_state
        persona,                                       # persona_state
        persona.get("name", ""),                       # p_name
        persona.get("age", ""),                        # p_age
        persona.get("gender", ""),                     # p_gender
        persona.get("personality", ""),                # p_personality
        persona.get("background", ""),                 # p_background
        gr.update(value=history, label=name, avatar_images=(None, avatar)),  # chatbot.chatbot
        f"## {name}",                                  # name_md
        f"*{role}*" if role else "",                   # role_md
        gr.update(value=avatar, visible=avatar is not None),  # avatar_img
        gr.update(value=char_id),                      # char_selector
        ui_history(history), ui_history(history),
        f"*✓ Loaded save for {name}.*",                # load_status
    )

def relationship_markdown(state, language):
    return "\n\n".join(f"**{label}:** {text}" for label, text in relationship_descriptions(state['relationship'], language))


def memory_choices(state):
    return [(('📌 ' if m['origin'] == 'manual' else '') + m['content'][:90], m['id'])
            for m in state['long_term_memory']]


def refresh_panels_fn(char_id: str, language: str, selected, request: gr.Request):
    state = load_conversation(session_key(request), char_id)
    valid = selected if any(m['id'] == selected for m in state['long_term_memory']) else None
    return relationship_markdown(state, language), gr.update(choices=memory_choices(state), value=valid)


def restore_panels_fn(char_id: str, language: str, request: gr.Request):
    state = load_conversation(session_key(request), char_id)
    return (relationship_markdown(state, language), gr.update(choices=memory_choices(state), value=None),
            state['relationship']['enabled']['romance'], state['relationship']['enabled']['attraction'], '', '')


def relationship_options_fn(romance, attraction, char_id: str, language: str, request: gr.Request):
    state = set_relationship_options(session_key(request), char_id, romance, attraction)
    return relationship_markdown(state, language)


def select_memory_fn(selected, char_id: str, request: gr.Request):
    state = load_conversation(session_key(request), char_id)
    return next((m['content'] for m in state['long_term_memory'] if m['id'] == selected), '')


def memory_action_fn(action, content, selected, char_id: str, language: str, request: gr.Request):
    try:
        state = change_memory(session_key(request), char_id, action, content, selected)
    except ValueError as exc:
        return gr.update(), gr.update(), content, str(exc)
    messages = {'remember': 'Memory saved.', 'edit': 'Memory updated.', 'forget': 'Memory forgotten.'}
    return (relationship_markdown(state, language), gr.update(choices=memory_choices(state), value=None),
            '', messages[action])


def edit_last_message_fn(char_id: str, request: gr.Request):
    state = load_conversation(session_key(request), char_id)
    history = state['recent_messages']
    index = next((i for i in range(len(history) - 1, -1, -1) if history[i]['role'] == 'user'), None)
    if index is None:
        raise gr.Error('There is no user message to edit yet.')
    text = history[index]['content']
    prefix = history[:index]
    sync_history(session_key(request), char_id, prefix)
    normalized = ui_history(prefix)
    return prefix, normalized, normalized, gr.update(value=text, interactive=True)


# ── Blocks layout ──────────────────────────────────────────────────────────────

with gr.Blocks(title=f"Chat with {char_name}") as demo:

    suggestion_texts = [gr.State("") for _ in range(4)]

    with gr.Sidebar():
        # ── Character selector ───────────────────────────────────────────────
        gr.Markdown("### Character library")
        category_selector = gr.Dropdown(
            choices=category_names,
            value=next((c for c in category_names if DEFAULT_CHARACTER in [x[1] for x in char_choices if x[0].startswith(c + " / ")]), None),
            label="Category",
            interactive=True,
        )
        category_character_choices = [
            (item["name"], item["id"]) for item in all_characters
            if category_selector.value in item.get("categories", [])
        ]
        char_selector = gr.Dropdown(
            choices=category_character_choices,
            value=DEFAULT_CHARACTER,
            label="Character",
            visible=len(char_choices) > 1,
            interactive=True,
        )

        # ── Character info ───────────────────────────────────────────────────
        name_md    = gr.Markdown(f"## {char_name}")
        role_md    = gr.Markdown(f"*{char_role}*" if char_role else "")
        avatar_img = gr.Image(
            value=avatar_path,
            show_label=False,
            height=220,
            container=False,
            visible=avatar_path is not None,
        )

        gr.Markdown("---")

        # ── Chat settings ────────────────────────────────────────────────────
        with gr.Accordion("⚙️ Chat settings", open=True):
            language_selector = gr.Dropdown(
                choices=LANGUAGES,
                value=DEFAULT_LANGUAGE,
                label="🌐 Language",
                interactive=True,
            )
            model_selector = gr.Dropdown(
                choices=MODELS,
                value=DEFAULT_MODEL,
                label="🤖 Model",
                interactive=True,
            )
            translator_toggle = gr.Checkbox(
                value=False,
                label="🔄 Use translator model",
                info="ON: dedicated model translates • OFF: main model handles language directly",
                interactive=True,
            )

        gr.Markdown("---")

        # ── Persona form ─────────────────────────────────────────────────────
        gr.Markdown("### 🎭 Your Persona")
        gr.Markdown("*Define who you're playing — all fields optional.*")

        p_name        = gr.Textbox(label="Name",        placeholder="e.g. Alex")
        p_age         = gr.Textbox(label="Age",         placeholder="e.g. 28")
        p_gender      = gr.Textbox(label="Gender",      placeholder="e.g. Female")
        p_personality = gr.Textbox(label="Personality", placeholder="e.g. curious, skeptical")
        p_background  = gr.Textbox(
            label="Background", lines=2,
            placeholder="e.g. A journalist investigating a disappearance",
        )

        with gr.Row():
            apply_btn = gr.Button("Apply", variant="primary", scale=2)
            clear_btn = gr.Button("Clear", scale=1)

        persona_status = gr.Markdown("")

        gr.Markdown("---")

        with gr.Accordion("Relationship", open=True):
            relationship_md = gr.Markdown(relationship_markdown(
                {'relationship': get_default_relationship()}, DEFAULT_LANGUAGE))
            romance_toggle = gr.Checkbox(False, label="Track romantic closeness")
            attraction_toggle = gr.Checkbox(False, label="Track sexual attraction")
            gr.Markdown("Each develops independently. Turning an option off clears its recorded developments.")
            gr.Markdown("Updates periodically with memory summaries, first after about 10 exchanges. Older turns may temporarily leave model context if summarization falls behind; the full chat remains saved.")

        with gr.Accordion("Memories", open=False):
            memory_selector = gr.Dropdown(choices=[], label="Saved memories", interactive=True)
            memory_editor = gr.Textbox(label="Memory", lines=3, max_length=2000,
                                       placeholder="Something you want this character to remember")
            with gr.Row():
                remember_btn = gr.Button("Remember")
                update_memory_btn = gr.Button("Update selected")
                forget_btn = gr.Button("Forget selected")
            memory_status = gr.Markdown("")
            gr.Markdown("Pinned memories are yours to edit. Forget excludes recorded source messages from future context; the visible chat stays intact.")

        # ── Save / Load ──────────────────────────────────────────────────────
        with gr.Accordion("💾 Save / Load", open=False):
            save_btn  = gr.Button("Save conversation", variant="secondary")
            save_file = gr.File(label="Download save file", visible=False, interactive=False)
            save_status = gr.Markdown("")

            gr.Markdown("---")

            load_upload = gr.File(
                label="Load save file (.json)",
                file_types=[".json"],
                file_count="single",
            )
            load_status = gr.Markdown("")

    # ── Chat + suggestions ─────────────────────────────────────────────────────
    # Construct here so built-in event chains and cancellation IDs share this Blocks.
    chatbot = SessionChatInterface(
        fn=respond,
        chatbot=gr.Chatbot(
            value=[{"role": "assistant", "content": greeting}],
            label=char_name,
            avatar_images=(None, avatar_path),
            height=480,
        ),
        additional_inputs=[
            gr.Slider(minimum=1,   maximum=2048, value=400,  step=1,    label="Max new tokens", render=False),
            gr.Slider(minimum=0.1, maximum=4.0,  value=0.7,  step=0.1,  label="Temperature", render=False),
            gr.Slider(minimum=0.1, maximum=1.0,  value=0.95, step=0.05, label="Top-p", render=False),
            persona_state,         # hidden — updated by the sidebar form
            char_id_state,
            language_state,
            model_state,
            use_translator_state,  # hidden — updated by the sidebar toggle
        ],
        additional_inputs_accordion=gr.Accordion("⚙️ Settings", open=False, render=False),
    )
    edit_last_btn = gr.Button("Edit last message", size="sm")
    gr.Markdown("Edit last message removes its old reply. Adjust the text and send to generate a replacement.")
    panel_timer = gr.Timer(10)


    suggest_btn = gr.Button("💡 Suggest replies", size="sm", variant="secondary")

    with gr.Group(visible=False) as suggestion_group:
        with gr.Row():
            s_btns = [
                gr.Button("", variant="secondary", size="sm", visible=False)
                for _ in range(4)
            ]

    # ── Events ─────────────────────────────────────────────────────────────────
    
    # Sync dropdowns / toggle → states
    language_selector.change(fn=lambda v: v, inputs=[language_selector], outputs=[language_state])
    model_selector.change(fn=lambda v: v,    inputs=[model_selector],    outputs=[model_state])
    translator_toggle.change(fn=lambda v: v, inputs=[translator_toggle], outputs=[use_translator_state])

    character_event = char_selector.input(
        fn=on_character_change,
        cancels=chatbot.generation_events,
        inputs=[char_selector],
        outputs=[char_id_state, name_md, role_md, avatar_img, chatbot.chatbot, chatbot.chatbot_state, chatbot.chatbot_value],
    )

    def characters_in_category(category, current_id):
        choices = [(item["name"], item["id"]) for item in all_characters
                   if category in item.get("categories", [])]
        selected = current_id if any(value == current_id for _, value in choices) else (choices[0][1] if choices else None)
        return gr.update(choices=choices, value=selected)

    category_selector.change(characters_in_category, [category_selector, char_id_state], [char_selector])

    clear_chat_event = chatbot.chatbot.clear(
        fn=clear_chat_fn,
        inputs=[char_id_state],
        outputs=[chatbot.chatbot, chatbot.chatbot_state, chatbot.chatbot_value],
        cancels=chatbot.generation_events,
        queue=False,
    )
    chatbot.textbox.stop(
        fn=stop_chat_fn,
        inputs=[chatbot.chatbot, char_id_state],
        outputs=[chatbot.chatbot_state, chatbot.chatbot_value],
        queue=False,
    )

    chatbot.chatbot_state.change(
        fn=persist_visible_history,
        inputs=[chatbot.chatbot_state, char_id_state],
        outputs=[],
        queue=False,
    )

    apply_btn.click(
        fn=apply_persona_fn,
        inputs=[p_name, p_age, p_gender, p_personality, p_background],
        outputs=[persona_state, persona_status],
    )

    clear_btn.click(
        fn=clear_persona_fn,
        inputs=[],
        outputs=[persona_state, p_name, p_age, p_gender, p_personality, p_background, persona_status],
    )

    suggestion_event = suggest_btn.click(
        fn=get_suggestions_fn,
        inputs=[char_id_state, model_state, language_state, persona_state],
        outputs=[suggestion_group] + s_btns + suggestion_texts,
    )

    gr.on(
        triggers=[language_selector.change, apply_btn.click, clear_btn.click,
                  char_selector.input, load_upload.change, chatbot.textbox.submit,
                  chatbot.chatbot.retry, chatbot.chatbot.clear, chatbot.chatbot.undo, edit_last_btn.click],
        fn=clear_suggestions_fn,
        inputs=[],
        outputs=[suggestion_group] + s_btns + suggestion_texts,
        cancels=[suggestion_event],
        queue=False,
    )

    for btn, text_state in zip(s_btns, suggestion_texts):
        btn.click(
            fn=lambda t: t,
            inputs=[text_state],
            outputs=[chatbot.textbox],
        )

    save_btn.click(
        fn=save_conversation_fn,
        inputs=[char_id_state, persona_state],
        outputs=[save_file, save_status],
    )

    gr.on(
        triggers=[char_selector.input, load_upload.change,
                  chatbot.chatbot_state.change, persona_state.change],
        fn=invalidate_save_fn,
        inputs=[],
        outputs=[save_file, save_status],
        queue=False,
    )

    load_event = load_upload.change(
        fn=load_conversation_fn,
        cancels=chatbot.generation_events,
        inputs=[load_upload, char_id_state],
        outputs=[
            char_id_state, persona_state,
            p_name, p_age, p_gender, p_personality, p_background,
            chatbot.chatbot,
            name_md, role_md, avatar_img, char_selector,
            chatbot.chatbot_state, chatbot.chatbot_value, load_status,
        ],
    )

    panel_outputs = [relationship_md, memory_selector, romance_toggle, attraction_toggle, memory_editor, memory_status]
    for event in (character_event, clear_chat_event, load_event):
        event.then(restore_panels_fn, [char_id_state, language_state], panel_outputs)
    panel_timer.tick(refresh_panels_fn, [char_id_state, language_state, memory_selector],
                     [relationship_md, memory_selector], queue=False, show_progress='hidden')
    language_selector.change(refresh_panels_fn, [char_id_state, language_selector, memory_selector],
                             [relationship_md, memory_selector], queue=False)
    gr.on(triggers=[romance_toggle.input, attraction_toggle.input], fn=relationship_options_fn,
          inputs=[romance_toggle, attraction_toggle, char_id_state, language_state], outputs=[relationship_md])
    memory_selector.input(select_memory_fn, [memory_selector, char_id_state], [memory_editor])
    for button, action in ((remember_btn, 'remember'), (update_memory_btn, 'edit'), (forget_btn, 'forget')):
        button.click(memory_action_fn,
                     [gr.State(action), memory_editor, memory_selector, char_id_state, language_state],
                     [relationship_md, memory_selector, memory_editor, memory_status])
    edit_last_btn.click(edit_last_message_fn, [char_id_state],
                        [chatbot.chatbot, chatbot.chatbot_state, chatbot.chatbot_value, chatbot.textbox],
                        cancels=chatbot.generation_events).then(
                            restore_panels_fn, [char_id_state, language_state], panel_outputs)


if __name__ == "__main__":
    demo.launch()