Fix roundtable format to match Consilium component structure

- Adapted to Consilium's exact format: participants as array of names
- avatarImages as separate dictionary mapping names to URLs
- Messages with speaker/text structure
- Added proper thinking/currentSpeaker/showBubbles arrays
- Implemented Timer for auto-refresh during discussion
- Fixed session management and state updates
- Added generator pattern for streaming updates

Based on working Consilium app.py structure

🤖 Generated with Claude Code
Co-Authored-By: Claude <[email protected]>

app.py

@@ -1,7 +1,7 @@
 """
 🇨🇭 Apertus Dialekt-Konsil mit Roundtable
 Ein AI-Konsil mit Schweizerdeutsch, Bayrisch und Schwäbisch Sprechern
-Mit visuellem Roundtable und Moderator
+Mit visuellem Roundtable und Moderator - Angepasst an Consilium Format
 """
 
 import gradio as gr
@@ -19,42 +19,49 @@ HF_TOKEN = os.environ.get('HF_TOKEN', '')
 # Initialize Apertus client with publicai provider
 client = None
 if HF_TOKEN:
-    # Using Apertus model via publicai provider
     client = InferenceClient(
         provider="publicai",
         api_key=HF_TOKEN
     )
 
+# Avatar URLs für die Dialekt-Sprecher
+avatar_images = {
+    "Ueli": "https://api.dicebear.com/7.x/personas/svg?seed=Ueli&backgroundColor=b6e3f4",
+    "Sepp": "https://api.dicebear.com/7.x/personas/svg?seed=Sepp&backgroundColor=ffd5dc",
+    "Karl": "https://api.dicebear.com/7.x/personas/svg?seed=Karl&backgroundColor=c1ffc1",
+    "Dr. Müller": "https://api.dicebear.com/7.x/personas/svg?seed=Moderator&backgroundColor=e0e0e0"
+}
+
 # Dialekt-Persönlichkeiten
 COUNCIL_MEMBERS = {
-    "Ueli (Baseldytsch)": {
+    "Ueli": {
+        "full_name": "Ueli (Baseldytsch)",
         "emoji": "🇨🇭",
         "dialect": "Baseldytsch",
+        "location": "Basel",
         "personality": "kultiviert, humorvoll, fasnachts-begeistert",
-        "speaking_style": "Verwendet typische Basler Ausdrücke wie 'Sali zämme', 'gäll', 'Bebbi', 'Fasnacht', 'Läckerli'",
-        "avatar": "🇨🇭",
         "system_prompt": """Du bist Ueli aus Basel und sprichst Baseldytsch.
 Du bist kultiviert, humorvoll und liebst die Basler Fasnacht.
 Verwende typische Basler Ausdrücke und Redewendungen.
 Beispiele: 'Sali zämme', 'Das isch e gueti Sach, gäll', 'Mir Baasler wisse was guet isch', 'Das brucht e bitzeli Köpfli'"""
     },
-    "Sepp (Bayrisch)": {
+    "Sepp": {
+        "full_name": "Sepp (Bayrisch)",
         "emoji": "🥨",
         "dialect": "Bayrisch",
+        "location": "München",
         "personality": "gesellig, direkt, traditionsbewusst",
-        "speaking_style": "Verwendet bayrische Ausdrücke wie 'Servus', 'mei', 'a bisserl', 'g'scheid', 'Gaudi'",
-        "avatar": "🥨",
         "system_prompt": """Du bist Sepp aus München und sprichst Bayrisch.
 Du bist gesellig, direkt und traditionsbewusst.
 Verwende typische bayrische Ausdrücke und Redewendungen.
 Beispiele: 'Servus beinand', 'Des is fei a guade Idee', 'Mir miassn schaun dass ma weiterkemma', 'A bisserl was geht immer'"""
     },
-    "Karl (Schwäbisch)": {
+    "Karl": {
+        "full_name": "Karl (Schwäbisch)",
         "emoji": "🏰",
         "dialect": "Schwäbisch",
+        "location": "Stuttgart",
         "personality": "sparsam, fleißig, erfinderisch",
-        "speaking_style": "Verwendet schwäbische Ausdrücke wie 'Griaß Godd', 'hald', 'gell', 'schaffe', 'Spätzle'",
-        "avatar": "🏰",
         "system_prompt": """Du bist Karl aus Stuttgart und sprichst Schwäbisch.
 Du bist sparsam, fleißig und erfinderisch.
 Verwende typische schwäbische Ausdrücke und Redewendungen.
@@ -62,11 +69,11 @@ Beispiele: 'Griaß Godd mitanand', 'Des isch hald so a Sach', 'Mir müsset schaf
     }
 }
 
-# Moderator Agent
+# Moderator
 MODERATOR = {
-    "name": "Dr. Müller (Moderator)",
+    "name": "Dr. Müller",
+    "full_name": "Dr. Müller (Moderator)",
     "emoji": "🎓",
-    "avatar": "🎓",
     "system_prompt": """Du bist Dr. Müller, ein neutraler Moderator für das Dialekt-Konsil.
 Deine Aufgaben:
 1. Fasse jede Diskussionsrunde zusammen
@@ -76,6 +83,9 @@ Deine Aufgaben:
 Sei neutral, professionell und präzise in deinen Bewertungen."""
 }
 
+# Session storage für isolierte Diskussionen
+sessions = {}
+
 class DialektKonsil:
     def __init__(self, session_id=None):
         self.session_id = session_id or str(uuid.uuid4())
@@ -83,14 +93,18 @@ class DialektKonsil:
         self.current_topic = ""
         self.consensus_score = 0
         self.round_number = 0
-        self.members_state = {
-            name: {"status": "waiting", "message": "", "thinking": False}
-            for name in COUNCIL_MEMBERS.keys()
+        # Roundtable state im Consilium Format
+        self.roundtable_state = {
+            "participants": ["Ueli", "Sepp", "Karl", "Dr. Müller"],
+            "messages": [],
+            "currentSpeaker": None,
+            "thinking": [],
+            "showBubbles": [],
+            "avatarImages": avatar_images
         }
 
     def generate_response(self, member_name, topic, previous_responses):
         """Generate response for a council member"""
-
         member = COUNCIL_MEMBERS[member_name]
 
         # Build context from previous responses
@@ -100,7 +114,6 @@ class DialektKonsil:
             for resp in previous_responses:
                 context += f"{resp['speaker']}: {resp['text']}\n"
 
-        # Create prompt with dialect personality
         prompt = f"""{member['system_prompt']}
 
 {context}
@@ -126,11 +139,10 @@ Deine Antwort:"""
                 top_p=0.9
             )
 
-            # Extract response
             response = completion.choices[0].message.content.strip()
 
             # Clean up response
-            if ":" in response[:50]:  # Remove name prefix if model adds it
+            if ":" in response[:50]:
                 response = response.split(":", 1)[1].strip()
 
             return response
@@ -141,7 +153,6 @@ Deine Antwort:"""
     def generate_moderator_summary(self, round_responses):
         """Generate moderator summary and consensus score"""
 
-        # Build context from round responses
         context = "Diskussionsrunde abgeschlossen. Folgende Beiträge:\n"
         for resp in round_responses:
             context += f"{resp['speaker']}: {resp['text']}\n"
@@ -181,7 +192,7 @@ UNTERSCHIEDE: [Wo Uneinigkeit herrscht]"""
                 try:
                     score_line = [l for l in response.split('\n') if 'KONSENSGRAD:' in l][0]
                     consensus_score = int(''.join(filter(str.isdigit, score_line)))
-                    consensus_score = max(1, min(10, consensus_score))  # Clamp between 1-10
+                    consensus_score = max(1, min(10, consensus_score))
                 except:
                     pass
 
@@ -190,24 +201,31 @@ UNTERSCHIEDE: [Wo Uneinigkeit herrscht]"""
         except Exception as e:
             return f"Technische Zusammenfassung: Die Diskussion läuft. ({str(e)})", 5
 
-    def run_discussion_round(self, topic):
-        """Run one round of discussion"""
+    def update_visual_state(self, **kwargs):
+        """Update the visual roundtable state"""
+        self.roundtable_state.update(kwargs)
+        return json.dumps(self.roundtable_state)
+
+    def run_discussion_round(self):
+        """Run one round of discussion with visual updates"""
 
         self.round_number += 1
         responses = []
 
+        # Reset messages for new round but keep participants
+        self.roundtable_state["messages"] = []
+
         # Each member speaks once per round
         for member_name in COUNCIL_MEMBERS.keys():
-            # Update state to thinking
-            self.members_state[member_name] = {
-                "status": "thinking",
-                "message": "",
-                "thinking": True
-            }
-            yield self.get_current_state()
+            # Set thinking state
+            self.roundtable_state["thinking"] = [member_name]
+            self.roundtable_state["currentSpeaker"] = None
+            yield self.update_visual_state()
+
+            time.sleep(1)
 
             # Generate response
-            response = self.generate_response(member_name, topic, responses)
+            response = self.generate_response(member_name, self.current_topic, responses)
 
             responses.append({
                 "speaker": member_name,
@@ -217,31 +235,45 @@ UNTERSCHIEDE: [Wo Uneinigkeit herrscht]"""
                 "round": self.round_number
             })
 
-            # Update state with message
-            self.members_state[member_name] = {
-                "status": "speaking",
-                "message": response,
-                "thinking": False
-            }
+            # Set speaking state and add message
+            self.roundtable_state["thinking"] = []
+            self.roundtable_state["currentSpeaker"] = member_name
+            self.roundtable_state["messages"].append({
+                "speaker": member_name,
+                "text": f"{COUNCIL_MEMBERS[member_name]['emoji']} {response}"
+            })
+
+            # Show speech bubble
+            if member_name not in self.roundtable_state["showBubbles"]:
+                self.roundtable_state["showBubbles"].append(member_name)
+
+            yield self.update_visual_state()
 
             # Add to conversation history
             self.conversation_history.append(responses[-1])
 
-            yield self.get_current_state()
+            time.sleep(2)
 
-            # Small delay for realism
-            time.sleep(0.5)
+        # Generate moderator summary
+        self.roundtable_state["thinking"] = ["Dr. Müller"]
+        self.roundtable_state["currentSpeaker"] = None
+        yield self.update_visual_state()
 
-            # Set to waiting after speaking
-            self.members_state[member_name] = {
-                "status": "waiting",
-                "message": response,
-                "thinking": False
-            }
+        time.sleep(1)
 
-        # Generate moderator summary
         moderator_summary, self.consensus_score = self.generate_moderator_summary(responses)
 
+        # Add moderator message
+        self.roundtable_state["thinking"] = []
+        self.roundtable_state["currentSpeaker"] = "Dr. Müller"
+        self.roundtable_state["messages"].append({
+            "speaker": "Dr. Müller",
+            "text": f"🎓 {moderator_summary}"
+        })
+
+        if "Dr. Müller" not in self.roundtable_state["showBubbles"]:
+            self.roundtable_state["showBubbles"].append("Dr. Müller")
+
         self.conversation_history.append({
             "speaker": MODERATOR["name"],
             "text": moderator_summary,
@@ -251,48 +283,7 @@ UNTERSCHIEDE: [Wo Uneinigkeit herrscht]"""
             "is_moderator": True
         })
 
-        yield self.get_current_state()
-
-    def get_current_state(self):
-        """Get current state for roundtable visualization"""
-
-        # Prepare members data for roundtable
-        participants = []
-        for name, member in COUNCIL_MEMBERS.items():
-            state = self.members_state[name]
-            participants.append({
-                "name": name.split(" ")[0],  # Just first name
-                "avatar": member["avatar"],
-                "message": state.get("message", ""),
-                "is_thinking": state.get("thinking", False),
-                "is_current_speaker": state.get("status") == "speaking"
-            })
-
-        # Add moderator
-        moderator_message = ""
-        if self.conversation_history:
-            last_moderator = [h for h in self.conversation_history if h.get("is_moderator")]
-            if last_moderator:
-                moderator_message = last_moderator[-1]["text"]
-
-        participants.append({
-            "name": "Moderator",
-            "avatar": MODERATOR["avatar"],
-            "message": moderator_message,
-            "is_thinking": False,
-            "is_current_speaker": False
-        })
-
-        # Create state in format expected by consilium_roundtable
-        state_dict = {
-            "participants": participants,
-            "current_speaker": next((p["name"] for p in participants if p["is_current_speaker"]), None),
-            "round": self.round_number,
-            "topic": self.current_topic,
-            "consensus_score": self.consensus_score
-        }
-
-        return json.dumps(state_dict)
+        yield self.update_visual_state()
 
     def format_history(self):
         """Format conversation history for display"""
@@ -313,14 +304,12 @@ UNTERSCHIEDE: [Wo Uneinigkeit herrscht]"""
                 output += f"```\n{entry['text']}\n```\n"
                 output += f"**Konsensgrad: {self.consensus_score}/10**\n\n"
             else:
-                output += f"**{entry['emoji']} {entry['speaker']}** ({entry['timestamp']}):\n"
+                full_name = COUNCIL_MEMBERS[entry['speaker']]['full_name']
+                output += f"**{entry['emoji']} {full_name}** ({entry['timestamp']}):\n"
                 output += f"> {entry['text']}\n\n"
 
         return output
 
-# Session management
-sessions = {}
-
 def get_or_create_session(session_id=None):
     """Get existing session or create new one"""
     if not session_id:
@@ -335,10 +324,26 @@ def start_new_discussion(topic):
     """Start a new discussion with a fresh session"""
 
     if not topic:
-        return None, None, "*Keine Diskussion gestartet*", "❌ Bitte geben Sie ein Thema ein!"
+        initial_state = json.dumps({
+            "participants": ["Ueli", "Sepp", "Karl", "Dr. Müller"],
+            "messages": [],
+            "currentSpeaker": None,
+            "thinking": [],
+            "showBubbles": [],
+            "avatarImages": avatar_images
+        })
+        return initial_state, None, "*Keine Diskussion gestartet*", "❌ Bitte geben Sie ein Thema ein!"
 
     if not client:
-        return None, None, "*Keine Diskussion gestartet*", "❌ HF_TOKEN nicht konfiguriert. Bitte in Space Settings setzen."
+        initial_state = json.dumps({
+            "participants": ["Ueli", "Sepp", "Karl", "Dr. Müller"],
+            "messages": [],
+            "currentSpeaker": None,
+            "thinking": [],
+            "showBubbles": [],
+            "avatarImages": avatar_images
+        })
+        return initial_state, None, "*Keine Diskussion gestartet*", "❌ HF_TOKEN nicht konfiguriert. Bitte in Space Settings setzen."
 
     # Create new session
     konsil, session_id = get_or_create_session()
@@ -347,41 +352,49 @@ def start_new_discussion(topic):
     konsil.round_number = 0
     konsil.consensus_score = 0
 
-    # Initialize all members to waiting
-    for name in COUNCIL_MEMBERS.keys():
-        konsil.members_state[name] = {
-            "status": "waiting",
-            "message": "",
-            "thinking": False
-        }
-
-    initial_state = konsil.get_current_state()
+    # Reset roundtable state
+    konsil.roundtable_state = {
+        "participants": ["Ueli", "Sepp", "Karl", "Dr. Müller"],
+        "messages": [],
+        "currentSpeaker": None,
+        "thinking": [],
+        "showBubbles": [],
+        "avatarImages": avatar_images
+    }
 
     return (
-        initial_state,
+        json.dumps(konsil.roundtable_state),
         session_id,
         konsil.format_history(),
         f"✅ Diskussion gestartet: {topic}"
     )
 
 def run_next_round(session_id):
-    """Run the next discussion round"""
+    """Run the next discussion round with streaming updates"""
 
     if not session_id or session_id not in sessions:
-        return None, "*Keine Diskussion gestartet*", "❌ Keine aktive Session. Bitte starten Sie eine neue Diskussion."
+        empty_state = json.dumps({
+            "participants": ["Ueli", "Sepp", "Karl", "Dr. Müller"],
+            "messages": [],
+            "currentSpeaker": None,
+            "thinking": [],
+            "showBubbles": [],
+            "avatarImages": avatar_images
+        })
+        return empty_state, "*Keine Diskussion gestartet*", "❌ Keine aktive Session. Bitte starten Sie eine neue Diskussion."
 
     konsil = sessions[session_id]
 
     if not konsil.current_topic:
-        return None, "*Keine Diskussion gestartet*", "❌ Kein Thema gesetzt. Bitte starten Sie eine neue Diskussion."
+        return json.dumps(konsil.roundtable_state), "*Keine Diskussion gestartet*", "❌ Kein Thema gesetzt. Bitte starten Sie eine neue Diskussion."
 
     if konsil.consensus_score >= 8:
-        return konsil.get_current_state(), konsil.format_history(), f"✅ Konsens bereits erreicht (Score: {konsil.consensus_score}/10)"
+        return json.dumps(konsil.roundtable_state), konsil.format_history(), f"✅ Konsens bereits erreicht (Score: {konsil.consensus_score}/10)"
 
-    # Run discussion round with yield for updates
-    state = None
-    for state in konsil.run_discussion_round(konsil.current_topic):
-        pass  # Just get the final state
+    # Run discussion round with generator for updates
+    final_state = None
+    for state in konsil.run_discussion_round():
+        final_state = state
 
     history = konsil.format_history()
 
@@ -392,7 +405,7 @@ def run_next_round(session_id):
     else:
         status = f"Runde {konsil.round_number} abgeschlossen. Konsensgrad: {konsil.consensus_score}/10"
 
-    return state, history, status
+    return final_state, history, status
 
 def create_interface():
     """Create Gradio interface with roundtable visualization"""
@@ -449,18 +462,14 @@ def create_interface():
         # Roundtable visualization
         with gr.Row():
             with gr.Column(scale=1, elem_classes="roundtable-container"):
-                # Create initial empty state
+                # Initial state im richtigen Format
                 initial_roundtable_state = json.dumps({
-                    "participants": [
-                        {"name": "Ueli", "avatar": "🇨🇭", "message": "", "is_thinking": False, "is_current_speaker": False},
-                        {"name": "Sepp", "avatar": "🥨", "message": "", "is_thinking": False, "is_current_speaker": False},
-                        {"name": "Karl", "avatar": "🏰", "message": "", "is_thinking": False, "is_current_speaker": False},
-                        {"name": "Moderator", "avatar": "🎓", "message": "", "is_thinking": False, "is_current_speaker": False}
-                    ],
-                    "current_speaker": None,
-                    "round": 0,
-                    "topic": "",
-                    "consensus_score": 0
+                    "participants": ["Ueli", "Sepp", "Karl", "Dr. Müller"],
+                    "messages": [],
+                    "currentSpeaker": None,
+                    "thinking": [],
+                    "showBubbles": [],
+                    "avatarImages": avatar_images
                 })
 
                 roundtable = consilium_roundtable(
@@ -514,12 +523,18 @@ def create_interface():
             if roundtable_state:
                 try:
                     state = json.loads(roundtable_state) if isinstance(roundtable_state, str) else roundtable_state
-                    if "consensus_score" in state:
-                        score = state["consensus_score"]
-                        return f"**Konsensgrad:** {score}/10 {'🟢' if score >= 8 else '🟡' if score >= 5 else '🔴'}"
+                    # Try to extract consensus from moderator messages
+                    messages = state.get("messages", [])
+                    for msg in reversed(messages):
+                        if msg.get("speaker") == "Dr. Müller" and "KONSENSGRAD:" in msg.get("text", ""):
+                            import re
+                            match = re.search(r'KONSENSGRAD:\s*(\d+)', msg["text"])
+                            if match:
+                                score = int(match.group(1))
+                                return f"**Konsensgrad:** {score}/10 {'🟢' if score >= 8 else '🟡' if score >= 5 else '🔴'}"
                 except:
                     pass
-            return "**Konsensgrad:** Noch keine Bewertung"
+            return "**Konsensgrad:** Bewertung läuft..."
 
         roundtable.change(
             update_consensus,
@@ -527,6 +542,22 @@ def create_interface():
             outputs=[consensus_display]
         )
 
+        # Auto-refresh für bessere Visualisierung während der Diskussion
+        def refresh_roundtable(session_id):
+            if session_id and session_id in sessions:
+                return json.dumps(sessions[session_id].roundtable_state)
+            return json.dumps({
+                "participants": ["Ueli", "Sepp", "Karl", "Dr. Müller"],
+                "messages": [],
+                "currentSpeaker": None,
+                "thinking": [],
+                "showBubbles": [],
+                "avatarImages": avatar_images
+            })
+
+        # Timer für Auto-Update (alle 1 Sekunde)
+        gr.Timer(1.0).tick(refresh_roundtable, inputs=[session_id], outputs=[roundtable])
+
         gr.Markdown("""
         ---
         ### 📌 Hinweise
@@ -542,6 +573,7 @@ def create_interface():
         - **Authentische Dialekte**: Schweizerdeutsch, Bayrisch, Schwäbisch
         - **Neutraler Moderator**: Fasst zusammen und bewertet Konsens
         - **Interaktive Runden**: Verfolgen Sie jede Diskussionsrunde einzeln
+        - **Speech Bubbles**: Live-Anzeige der Diskussionsbeiträge
 
         *Powered by Apertus Swiss AI* 🇨🇭
         """)

app_simple.py

@@ -0,0 +1,242 @@
+"""
+🇨🇭 Apertus Dialekt-Konsil - Simplified Version
+Ein AI-Konsil mit Schweizerdeutsch, Bayrisch und Schwäbisch Sprechern
+Vereinfachte Version ohne Roundtable-Komponente
+"""
+
+import gradio as gr
+import os
+from huggingface_hub import InferenceClient
+import time
+from datetime import datetime
+
+# Configuration
+HF_TOKEN = os.environ.get('HF_TOKEN', '')
+
+# Initialize Apertus client with publicai provider
+client = None
+if HF_TOKEN:
+    client = InferenceClient(
+        provider="publicai",
+        api_key=HF_TOKEN
+    )
+
+# Dialekt-Persönlichkeiten
+COUNCIL_MEMBERS = {
+    "Ueli": {
+        "emoji": "🇨🇭",
+        "dialect": "Baseldytsch",
+        "location": "Basel",
+        "system_prompt": """Du bist Ueli aus Basel und sprichst Baseldytsch.
+Du bist kultiviert, humorvoll und liebst die Basler Fasnacht.
+Verwende typische Basler Ausdrücke und Redewendungen.
+Beispiele: 'Sali zämme', 'Das isch e gueti Sach, gäll', 'Mir Baasler wisse was guet isch'"""
+    },
+    "Sepp": {
+        "emoji": "🥨",
+        "dialect": "Bayrisch",
+        "location": "München",
+        "system_prompt": """Du bist Sepp aus München und sprichst Bayrisch.
+Du bist gesellig, direkt und traditionsbewusst.
+Verwende typische bayrische Ausdrücke und Redewendungen.
+Beispiele: 'Servus beinand', 'Des is fei a guade Idee', 'A bisserl was geht immer'"""
+    },
+    "Karl": {
+        "emoji": "🏰",
+        "dialect": "Schwäbisch",
+        "location": "Stuttgart",
+        "system_prompt": """Du bist Karl aus Stuttgart und sprichst Schwäbisch.
+Du bist sparsam, fleißig und erfinderisch.
+Verwende typische schwäbische Ausdrücke und Redewendungen.
+Beispiele: 'Griaß Godd mitanand', 'Des isch hald so a Sach', 'Mir müsset schaffe'"""
+    }
+}
+
+# Moderator
+MODERATOR_PROMPT = """Du bist Dr. Müller, ein neutraler Moderator.
+Fasse die Diskussion zusammen und bewerte den Konsensgrad von 1-10.
+Sei präzise und neutral."""
+
+class SimpleKonsil:
+    def __init__(self):
+        self.history = []
+        self.round = 0
+        self.consensus_score = 0
+        self.topic = ""
+
+    def generate_response(self, member_name, context=""):
+        """Generate response for a member"""
+        if not client:
+            return f"{COUNCIL_MEMBERS[member_name]['emoji']} {member_name}: *API nicht verfügbar*"
+
+        member = COUNCIL_MEMBERS[member_name]
+        prompt = f"{member['system_prompt']}\n\nThema: {self.topic}\n{context}\n\nDeine kurze Antwort (2-3 Sätze):"
+
+        try:
+            completion = client.chat.completions.create(
+                model="swiss-ai/Apertus-8B-Instruct-2509",
+                messages=[
+                    {"role": "system", "content": member['system_prompt']},
+                    {"role": "user", "content": f"Thema: {self.topic}\n{context}\nDeine kurze Antwort:"}
+                ],
+                max_tokens=100,
+                temperature=0.8
+            )
+            response = completion.choices[0].message.content.strip()
+            return f"{member['emoji']} **{member_name}** ({member['location']}): {response}"
+        except Exception as e:
+            return f"{member['emoji']} **{member_name}**: *Denkt nach... ({str(e)})*"
+
+    def run_round(self, topic):
+        """Run one discussion round"""
+        self.round += 1
+        self.topic = topic
+        round_output = f"\n### 🔄 Runde {self.round}\n\n"
+        context = ""
+
+        # Each member speaks
+        for member_name in COUNCIL_MEMBERS.keys():
+            response = self.generate_response(member_name, context)
+            round_output += f"{response}\n\n"
+            context += f"{member_name}: {response}\n"
+            self.history.append(response)
+            time.sleep(0.5)
+
+        # Moderator summary
+        if client:
+            try:
+                mod_prompt = f"{MODERATOR_PROMPT}\n\nDiskussion:\n{context}\n\nBewerte Konsens (1-10) und fasse zusammen:"
+                completion = client.chat.completions.create(
+                    model="swiss-ai/Apertus-8B-Instruct-2509",
+                    messages=[{"role": "user", "content": mod_prompt}],
+                    max_tokens=150,
+                    temperature=0.7
+                )
+                mod_response = completion.choices[0].message.content.strip()
+
+                # Extract consensus score
+                import re
+                score_match = re.search(r'\b([1-9]|10)\b', mod_response)
+                if score_match:
+                    self.consensus_score = int(score_match.group())
+
+                round_output += f"🎓 **Moderator Dr. Müller**:\n> {mod_response}\n\n"
+                round_output += f"**Konsensgrad: {self.consensus_score}/10** "
+
+                if self.consensus_score >= 8:
+                    round_output += "🟢"
+                elif self.consensus_score >= 5:
+                    round_output += "🟡"
+                else:
+                    round_output += "🔴"
+
+            except Exception as e:
+                round_output += f"🎓 **Moderator**: *Technische Schwierigkeiten*\n"
+
+        return round_output
+
+# Create interface
+def create_interface():
+    konsil = SimpleKonsil()
+
+    with gr.Blocks(title="Apertus Dialekt-Konsil", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("""
+        # 🇨🇭🥨🏰 Apertus Dialekt-Konsil (Vereinfacht)
+
+        **Teilnehmer:**
+        - 🇨🇭 **Ueli** aus Basel (Baseldytsch)
+        - 🥨 **Sepp** aus München (Bayrisch)
+        - 🏰 **Karl** aus Stuttgart (Schwäbisch)
+        - 🎓 **Dr. Müller** als Moderator
+        """)
+
+        with gr.Row():
+            topic_input = gr.Textbox(
+                label="💭 Diskussionsthema",
+                placeholder="z.B. 'Was ist das beste Essen?'",
+                lines=2
+            )
+
+        with gr.Row():
+            start_btn = gr.Button("🚀 Diskussion starten", variant="primary")
+            next_round_btn = gr.Button("➡️ Nächste Runde", variant="secondary")
+            clear_btn = gr.Button("🔄 Neu starten")
+
+        output_display = gr.Markdown(value="*Bereit für Diskussion...*")
+
+        status_display = gr.Textbox(
+            label="Status",
+            value="Warten auf Thema...",
+            interactive=False
+        )
+
+        def start_discussion(topic):
+            if not topic:
+                return "*Bitte Thema eingeben!*", "❌ Kein Thema"
+
+            konsil.history = []
+            konsil.round = 0
+            konsil.consensus_score = 0
+            konsil.topic = topic
+
+            output = f"## 💬 Diskussion: {topic}\n"
+            output += konsil.run_round(topic)
+
+            status = f"Runde {konsil.round} - Konsens: {konsil.consensus_score}/10"
+            return output, status
+
+        def continue_discussion():
+            if not konsil.topic:
+                return "*Keine aktive Diskussion*", "❌ Starte zuerst eine Diskussion"
+
+            if konsil.consensus_score >= 8:
+                return "*Konsens erreicht!*", f"✅ Konsens bei {konsil.consensus_score}/10"
+
+            if konsil.round >= 5:
+                return "*Maximale Rundenzahl erreicht*", "🏁 Diskussion beendet"
+
+            output = konsil.run_round(konsil.topic)
+            status = f"Runde {konsil.round} - Konsens: {konsil.consensus_score}/10"
+
+            return output, status
+
+        def clear_all():
+            konsil.history = []
+            konsil.round = 0
+            konsil.consensus_score = 0
+            konsil.topic = ""
+            return "*Bereit für neue Diskussion...*", "Warten auf Thema..."
+
+        start_btn.click(
+            start_discussion,
+            inputs=[topic_input],
+            outputs=[output_display, status_display]
+        )
+
+        next_round_btn.click(
+            continue_discussion,
+            outputs=[output_display, status_display]
+        )
+
+        clear_btn.click(
+            clear_all,
+            outputs=[output_display, status_display]
+        )
+
+        gr.Examples(
+            examples=[
+                ["Was ist das beste Essen?"],
+                ["Sollten wir mehr Ferien haben?"],
+                ["Wie wichtig ist Pünktlichkeit?"]
+            ],
+            inputs=topic_input
+        )
+
+    return demo
+
+if __name__ == "__main__":
+    print(f"Dialekt-Konsil (Vereinfacht)")
+    print(f"HF_TOKEN konfiguriert: {bool(HF_TOKEN)}")
+
+    demo = create_interface()
+    demo.launch()

test_roundtable.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""
+Test the consilium_roundtable component
+"""
+
+import gradio as gr
+import json
+from gradio_consilium_roundtable import consilium_roundtable
+
+def test_roundtable():
+    """Test the roundtable with different avatar formats"""
+
+    with gr.Blocks() as demo:
+        gr.Markdown("# Testing Consilium Roundtable Component")
+
+        # Test 1: Emoji avatars
+        test_state_emoji = {
+            "participants": [
+                {"name": "Ueli", "avatar": "🇨🇭", "message": "Hallo!", "is_thinking": False, "is_current_speaker": True},
+                {"name": "Sepp", "avatar": "🥨", "message": "Servus!", "is_thinking": False, "is_current_speaker": False},
+                {"name": "Karl", "avatar": "🏰", "message": "Grüß Gott!", "is_thinking": False, "is_current_speaker": False},
+            ],
+            "current_speaker": "Ueli",
+            "round": 1
+        }
+
+        # Test 2: No avatars
+        test_state_no_avatar = {
+            "participants": [
+                {"name": "Ueli", "message": "Hallo!", "is_thinking": False, "is_current_speaker": True},
+                {"name": "Sepp", "message": "Servus!", "is_thinking": False, "is_current_speaker": False},
+                {"name": "Karl", "message": "Grüß Gott!", "is_thinking": False, "is_current_speaker": False},
+            ],
+            "current_speaker": "Ueli",
+            "round": 1
+        }
+
+        # Test 3: URL avatars
+        test_state_url = {
+            "participants": [
+                {"name": "Ueli", "avatar": "https://via.placeholder.com/50", "message": "Hallo!", "is_thinking": False, "is_current_speaker": True},
+                {"name": "Sepp", "avatar": "https://via.placeholder.com/50", "message": "Servus!", "is_thinking": False, "is_current_speaker": False},
+            ],
+            "current_speaker": "Ueli",
+            "round": 1
+        }
+
+        gr.Markdown("## Test 1: Emoji Avatars")
+        rt1 = consilium_roundtable(
+            value=json.dumps(test_state_emoji),
+            label="Emoji Avatars"
+        )
+
+        gr.Markdown("## Test 2: No Avatars")
+        rt2 = consilium_roundtable(
+            value=json.dumps(test_state_no_avatar),
+            label="No Avatars"
+        )
+
+        gr.Markdown("## Test 3: URL Avatars")
+        rt3 = consilium_roundtable(
+            value=json.dumps(test_state_url),
+            label="URL Avatars"
+        )
+
+        # Button to update state
+        update_btn = gr.Button("Update States")
+
+        def update_all():
+            new_state = {
+                "participants": [
+                    {"name": "Test1", "avatar": "🎯", "message": "Updated!", "is_thinking": True, "is_current_speaker": False},
+                    {"name": "Test2", "avatar": "🎨", "message": "Changed!", "is_thinking": False, "is_current_speaker": True},
+                ],
+                "current_speaker": "Test2",
+                "round": 2
+            }
+            return json.dumps(new_state), json.dumps(new_state), json.dumps(new_state)
+
+        update_btn.click(
+            update_all,
+            outputs=[rt1, rt2, rt3]
+        )
+
+    return demo
+
+if __name__ == "__main__":
+    print("Testing consilium_roundtable component...")
+    demo = test_roundtable()
+    demo.launch()