character conversation

Author: kavyabhand

ai/generation.py

@@ -173,6 +173,9 @@ def generate_entity(
 
             entity = create_entity(entity_data, user_input, session_id)
 
+            # Generate portrait in background (non-blocking)
+            _spawn_portrait_generation(entity)
+
             arrival_content = (
                 f"On Day {entity.get('world_day', 1)}, {profile.name} arrived in "
                 f"{profile.suggested_location}. {profile.arrival_note}"
@@ -220,6 +223,25 @@ def generate_entity(
     return None, "The Oracle was silent. Try again."
 
 
+def _spawn_portrait_generation(entity: dict) -> None:
+    """Fire-and-forget portrait generation in a background thread."""
+    import threading
+    def _gen():
+        try:
+            from ai.image_generation import generate_soul_portrait
+            from world.database import db_session
+            path = generate_soul_portrait(entity)
+            if path:
+                with db_session() as conn:
+                    conn.execute(
+                        "UPDATE entities SET portrait_url=? WHERE id=?",
+                        (path, entity["id"])
+                    )
+        except Exception:
+            pass
+    threading.Thread(target=_gen, daemon=True).start()
+
+
 def _generate_secret_name(true_name: str) -> str:
     words = true_name.replace("The ", "").split()
     if len(words) >= 2:

ai/image_generation.py

@@ -0,0 +1,98 @@
+"""Soul portrait generation via HuggingFace Inference API (FLUX.1-schnell)."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+PORTRAITS_DIR = Path(__file__).parent.parent / "assets" / "generated"
+
+
+def _portraits_dir() -> Path:
+    PORTRAITS_DIR.mkdir(parents=True, exist_ok=True)
+    return PORTRAITS_DIR
+
+
+def _build_prompt(entity: dict) -> str:
+    """Build a vivid image prompt from entity data."""
+    appearance = (entity.get("appearance") or "")[:220]
+    etype = entity.get("type", "character")
+    traits = entity.get("personality_traits") or []
+    trait_str = ", ".join(t for t in traits[:2]) if traits else ""
+
+    type_style = {
+        "character": "fantasy portrait, close-up, mysterious figure",
+        "creature":  "fantasy creature, full body, magical beast",
+        "object":    "magical enchanted artifact, studio lighting, detailed",
+        "place":     "mystical location concept art, atmospheric, wide view",
+    }.get(etype, "fantasy entity")
+
+    prompt = (
+        f"{appearance}. {type_style}. {trait_str}. "
+        "Dark fantasy art style, painterly, dramatic atmospheric lighting, "
+        "highly detailed, moody, cinematic, oil painting, intricate details, "
+        "no text, no watermark, masterpiece quality"
+    )
+    return prompt[:500]
+
+
+def generate_soul_portrait(entity: dict) -> str | None:
+    """
+    Generate a portrait image for the given entity using HF Inference API.
+    Returns the local file path (string) on success, or None on failure/skip.
+    Silently skips if HF_TOKEN is not set.
+    """
+    import requests
+
+    hf_token = os.environ.get("HF_TOKEN")
+    if not hf_token:
+        return None
+
+    entity_id = entity.get("id")
+    if not entity_id:
+        return None
+
+    out_path = _portraits_dir() / f"{entity_id}.jpg"
+    if out_path.exists():
+        return str(out_path)
+
+    prompt = _build_prompt(entity)
+
+    # Try FLUX.1-schnell first (best quality, still fast)
+    models = [
+        "black-forest-labs/FLUX.1-schnell",
+        "stabilityai/sdxl-turbo",
+    ]
+
+    for model in models:
+        try:
+            resp = requests.post(
+                f"https://api-inference.huggingface.co/models/{model}",
+                headers={"Authorization": f"Bearer {hf_token}"},
+                json={
+                    "inputs": prompt,
+                    "parameters": {
+                        "num_inference_steps": 4,
+                        "width": 512,
+                        "height": 512,
+                        "guidance_scale": 0.0,
+                    },
+                },
+                timeout=45,
+            )
+            if resp.status_code == 200 and resp.content:
+                out_path.write_bytes(resp.content)
+                return str(out_path)
+        except Exception:
+            continue
+
+    return None
+
+
+def portrait_url_for(entity: dict) -> str | None:
+    """Return the Gradio-servable URL for a portrait if it exists on disk."""
+    entity_id = entity.get("id")
+    if not entity_id:
+        return None
+    p = PORTRAITS_DIR / f"{entity_id}.jpg"
+    return str(p) if p.exists() else None

ai/interaction.py

@@ -35,11 +35,22 @@ def generate_interaction(
     event_title = current_event["title"] if current_event else "None"
     event_desc = current_event["description"] if current_event else "None"
 
+    # Build quest context lines
+    quest_a = entity_a.get("active_quest")
+    quest_b = entity_b.get("active_quest")
+    quest_context = ""
+    if quest_a:
+        quest_context += f"\nACTIVE QUEST for {entity_a['name']}: {quest_a}"
+    if quest_b:
+        quest_context += f"\nACTIVE QUEST for {entity_b['name']}: {quest_b}"
+    if quest_context:
+        quest_context = f"\n--- PLAYER-ASSIGNED QUESTS (weave these into the interaction outcome) ---{quest_context}\n"
+
     user_prompt = prompts.INTERACTION_USER.format(
         location_name=location["name"],
         location_description=location["short_description"],
         current_event_title=event_title,
-        current_event_description=event_desc,
+        current_event_description=event_desc + quest_context,
         entity_a_name=entity_a["name"],
         entity_a_type=entity_a["type"],
         entity_a_appearance_summary=entity_a["appearance"][:200],

app.py

@@ -13,6 +13,8 @@
 load_dotenv()
 
 from world.database import get_world_state, init_database
+from world.quests import assign_quest, get_entity_quest, get_active_quests
+from world.presence import heartbeat as presence_heartbeat, get_active_count, get_recent_arrivals
 from world.entities import (
     check_rate_limit,
     get_all_entities,
@@ -301,6 +303,40 @@ def chat_with_soul(soul_id: str, player_message: str) -> str:
         return entity.get("greeting") or "..."
 
 
+def assign_quest_api(entity_id: str, quest_title: str) -> str:
+    """Assign a quest to a soul. Called from the diorama iframe via Gradio API."""
+    if not entity_id or not quest_title or not quest_title.strip():
+        return ""
+    try:
+        from world.entities import get_entity
+        entity = get_entity(entity_id)
+        if not entity:
+            return "Soul not found."
+        q = assign_quest(entity_id, quest_title.strip()[:200])
+        return f"Quest assigned: {q['title']}"
+    except Exception as e:
+        return f"Could not assign quest: {e}"
+
+
+def get_live_presence(session_id: str) -> str:
+    """Heartbeat + return live visitor HTML."""
+    try:
+        presence_heartbeat(session_id)
+        count = get_active_count()
+        arrivals = get_recent_arrivals(since_seconds=120)
+        parts = []
+        if count > 1:
+            parts.append(f'<span class="presence-count">⬡ {count} visitors in the Realm right now</span>')
+        if arrivals:
+            names = ", ".join(a["display_name"] for a in arrivals[:3])
+            parts.append(f'<span class="presence-arrivals">Recently summoned: {names}</span>')
+        if not parts:
+            return ""
+        return f'<div class="presence-bar">{"  ·  ".join(parts)}</div>'
+    except Exception:
+        return ""
+
+
 def trigger_live_tick() -> str:
     """Run one simulation tick on demand and return a summary."""
     try:
@@ -381,6 +417,7 @@ def build_app() -> gr.Blocks:
     with gr.Blocks(**blocks_kwargs) as demo:
         session_id = gr.State(value=str(uuid.uuid4()))
 
+        presence_bar = gr.HTML(value="", elem_id="presence-bar")
         header = gr.HTML(value=get_header_html(), elem_classes=["realm-header-wrap"])
 
         with gr.Tabs(elem_classes=["realm-tabs"]) as tabs:
@@ -689,18 +726,36 @@ def _map_open_diorama(pick):
             outputs=[world_map, header, current_event, activity_feed, world_vignette, featured_chars, realm_pulse],
         )
 
-        # ── Soul chat API (called from diorama iframe via fetch) ──
+        # ── Soul chat API ──
         chat_soul_id_comp = gr.Textbox(visible=False, elem_id="chat_soul_id_input")
         chat_msg_comp     = gr.Textbox(visible=False, elem_id="chat_message_input")
         chat_resp_comp    = gr.Textbox(visible=False, elem_id="chat_response_output")
-
         chat_msg_comp.change(
             fn=chat_with_soul,
             inputs=[chat_soul_id_comp, chat_msg_comp],
             outputs=[chat_resp_comp],
             api_name="chat_with_soul",
         )
 
+        # ── Quest API ──
+        quest_entity_comp = gr.Textbox(visible=False, elem_id="quest_entity_input")
+        quest_title_comp  = gr.Textbox(visible=False, elem_id="quest_title_input")
+        quest_resp_comp   = gr.Textbox(visible=False, elem_id="quest_response_output")
+        quest_title_comp.change(
+            fn=assign_quest_api,
+            inputs=[quest_entity_comp, quest_title_comp],
+            outputs=[quest_resp_comp],
+            api_name="assign_quest",
+        )
+
+        # ── Presence heartbeat (every 10s) ──
+        presence_timer = gr.Timer(10)
+        presence_timer.tick(
+            fn=get_live_presence,
+            inputs=[session_id],
+            outputs=[presence_bar],
+        )
+
         book_filter.change(filter_book, [book_filter, book_search], [book_display])
         book_search.change(filter_book, [book_filter, book_search], [book_display])
 
@@ -776,7 +831,10 @@ def _map_open_diorama(pick):
         "server_name": "0.0.0.0",
         "server_port": int(os.environ.get("PORT", 7860)),
         "share": False,
-        "allowed_paths": assets.allowed_paths() + [str(Path(tempfile.gettempdir()) / "aether_soul_cards")],
+        "allowed_paths": assets.allowed_paths() + [
+            str(Path(tempfile.gettempdir()) / "aether_soul_cards"),
+            str(Path(__file__).parent / "assets" / "generated"),
+        ],
     }
     if GRADIO_MAJOR >= 6:
         launch_kwargs["css"] = CUSTOM_CSS