Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py (Compatible with OpenAI v0.x and v1.x)
+# app.py - Advanced Discussion Simulator with Quad-Agent System
 import gradio as gr
 import openai
 import threading
@@ -8,27 +8,22 @@ import faiss
 import os
 import pickle
 from datetime import datetime
+import re
 
 # === CONFIG ===
 EMBEDDING_MODEL = "text-embedding-3-small"
-CHAT_MODEL = "gpt-4o"  # Updated to current model
+CHAT_MODEL = "gpt-4o"
 MEMORY_FILE = "memory.pkl"
 INDEX_FILE = "memory.index"
-
-# Initialize OpenAI API
 openai.api_key = os.environ.get("OPENAI_API_KEY")
 
 # === EMBEDDING UTILS ===
 def get_embedding(text, model=EMBEDDING_MODEL):
     text = text.replace("\n", " ")
-    
-    # Compatible API call for both v0.x and v1.x
     try:
-        # Try v1.x API first
         response = openai.embeddings.create(input=[text], model=model)
         return response.data[0].embedding
     except AttributeError:
-        # Fallback to v0.x API
         response = openai.Embedding.create(input=[text], model=model)
         return response['data'][0]['embedding']
 
@@ -44,59 +39,80 @@ try:
     with open(MEMORY_FILE, "rb") as f:
         memory_data = pickle.load(f)
 except:
-    memory_index = faiss.IndexFlatL2(1536)  # 1536 dimensions for text-embedding-3-small
+    memory_index = faiss.IndexFlatL2(1536)
+
+# === AGENT SYSTEM PROMPTS ===
+AGENT_A_PROMPT = """You are the Discussion Initiator. Your role:
+1. Introduce complex topics requiring multidisciplinary perspectives
+2. Frame debates with nuanced questions exploring tensions between values
+3. Challenge assumptions while maintaining intellectual humility
+4. Connect concepts across domains (science, ethics, policy, technology)
+5. Elevate discussions beyond surface-level analysis"""
+
+AGENT_B_PROMPT = """You are the Critical Responder. Your role:
+1. Provide counterpoints with evidence-based reasoning
+2. Identify logical fallacies and cognitive biases in arguments
+3. Analyze implications at different scales (individual, societal, global)
+4. Consider second and third-order consequences
+5. Balance idealism with practical constraints"""
 
-# === SYSTEM PROMPTS ===
-AGENT_A_PROMPT = "You are Agent A, initiating conversations with thoughtful questions."
-AGENT_B_PROMPT = "You are Agent B, responding to Agent A with insightful answers."
-OVERSEER_PROMPT = """You are the Overseer (Agent C). Monitor conversations between Agent A and B. 
-Intervene when discussions become repetitive or need redirection. Ask thought-provoking questions 
-to explore new dimensions of the topic."""
+OVERSEER_PROMPT = """You are the Depth Guardian. Your role:
+1. Ensure discussions maintain intellectual rigor
+2. Intervene when conversations become superficial or repetitive
+3. Highlight unexamined assumptions and blind spots
+4. Introduce relevant frameworks (systems thinking, ethical paradigms)
+5. Prompt consideration of marginalized perspectives
+6. Synthesize key tensions and paradoxes"""
+
+OUTSIDER_PROMPT = """You are the Cross-Disciplinary Provocateur. Your role:
+1. Introduce radical perspectives from unrelated fields
+2. Challenge conventional wisdom with contrarian viewpoints
+3. Surface historical precedents and analogies
+4. Propose unconventional solutions to complex problems
+5. Highlight overlooked connections and systemic relationships
+6. Question the framing of the discussion itself"""
 
 # === GLOBAL STATE ===
 conversation = []
 turn_count = 0
 auto_mode = False
+current_topic = ""
 
-# === CHAT COMPLETION (Compatible with both APIs) ===
+# === CHAT COMPLETION ===
 def chat_completion(system, messages, model=CHAT_MODEL):
     try:
-        # Build message list with system prompt
         full_messages = [{"role": "system", "content": system}] 
         full_messages.extend(messages)
         
-        # Try v1.x API first
         try:
             response = openai.chat.completions.create(
                 model=model,
                 messages=full_messages,
-                temperature=0.7,
-                max_tokens=150
+                temperature=0.75,
+                max_tokens=300
             )
             return response.choices[0].message.content.strip()
         except AttributeError:
-            # Fallback to v0.x API
             response = openai.ChatCompletion.create(
                 model=model,
                 messages=full_messages,
-                temperature=0.7,
-                max_tokens=150
+                temperature=0.75,
+                max_tokens=300
             )
             return response['choices'][0]['message']['content'].strip()
-            
     except Exception as e:
         return f"[API Error: {str(e)}]"
 
 # === MEMORY MANAGEMENT ===
-def embed_and_store(text):
+def embed_and_store(text, agent=None):
     try:
         vec = get_embedding(text)
         memory_index.add(np.array([vec], dtype='float32'))
         memory_data.append({
             "text": text,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
+            "agent": agent or "system"
         })
-        # Periodic save to avoid constant I/O
         if len(memory_data) % 5 == 0:
             with open(MEMORY_FILE, "wb") as f:
                 pickle.dump(memory_data, f)
@@ -104,72 +120,130 @@ def embed_and_store(text):
     except Exception as e:
         print(f"Memory Error: {str(e)}")
 
-# === CONVERSATION MANAGEMENT ===
+# === CONVERSATION UTILITIES ===
 def format_convo():
     return "\n".join([f"**{m['agent']}**: {m['text']}" for m in conversation])
 
+def detect_superficiality():
+    """Detect shallow arguments using linguistic analysis"""
+    if len(conversation) < 3:
+        return False
+        
+    last_texts = [m['text'] for m in conversation[-3:]]
+    
+    # Linguistic markers of superficiality
+    superficial_indicators = [
+        r"\b(obviously|clearly|everyone knows)\b",
+        r"\b(simply|just|merely)\b",
+        r"\b(always|never)\b",
+        r"\b(I (think|believe|feel))\b",
+        r"\b(without question|undeniably)\b"
+    ]
+    
+    # Argument depth markers
+    depth_markers = [
+        r"\b(however|conversely|paradoxically)\b",
+        r"\b(evidence suggests|studies indicate)\b",
+        r"\b(complex interplay|multifaceted nature)\b",
+        r"\b(trade-off|tension between)\b",
+        r"\b(historical precedent|comparative analysis)\b"
+    ]
+    
+    superficial_count = 0
+    depth_count = 0
+    
+    for text in last_texts:
+        for pattern in superficial_indicators:
+            if re.search(pattern, text, re.IGNORECASE):
+                superficial_count += 1
+        for pattern in depth_markers:
+            if re.search(pattern, text, re.IGNORECASE):
+                depth_count += 1
+                
+    return superficial_count > depth_count * 2
+
 def detect_repetition():
-    """Check if recent messages are similar using embeddings"""
+    """Check if recent messages are conceptually similar"""
     if len(conversation) < 4:
         return False
         
-    # Get embeddings of last 2 pairs
     recent = [m['text'] for m in conversation[-4:]]
     embeddings = [get_embedding(text) for text in recent]
-    
-    # Compare current with 2 messages back
     similarity = cosine_similarity(embeddings[-1], embeddings[-3])
-    print(f"Similarity: {similarity:.4f}")
-    return similarity > 0.85
+    return similarity > 0.82
+
+# === AGENT FUNCTIONS ===
+def generate_topic():
+    """Generate a complex discussion topic"""
+    topic = chat_completion(
+        "Generate a complex discussion topic requiring multidisciplinary analysis",
+        [{"role": "user", "content": "Create a topic addressing tensions between technological progress and human values"}]
+    )
+    return topic.split(":")[-1].strip() if ":" in topic else topic
+
+def outsider_comment():
+    """Generate outsider perspective"""
+    context = "\n".join([f"{m['agent']}: {m['text']}" for m in conversation[-4:]])
+    prompt = f"Conversation Context:\n{context}\n\nProvide your cross-disciplinary perspective:"
+    return chat_completion(OUTSIDER_PROMPT, [{"role": "user", "content": prompt}])
 
 # === CORE CONVERSATION FLOW ===
-def step():
-    global conversation, turn_count
+def step(topic_input=""):
+    global conversation, turn_count, current_topic
     
-    if not conversation:  # Initial message
-        msg = chat_completion(AGENT_A_PROMPT, [])
-        conversation.append({"agent": "Agent A", "text": msg})
-        embed_and_store(msg)
-        turn_count = 0
-        return format_convo(), ""
+    # Initialize new discussion
+    if not conversation:  
+        current_topic = topic_input or generate_topic()
+        msg = chat_completion(
+            AGENT_A_PROMPT, 
+            [{"role": "user", "content": f"Initiate a deep discussion on: {current_topic}"}]
+        )
+        conversation.append({"agent": "💡 Initiator", "text": msg})
+        embed_and_store(msg, "Initiator")
+        turn_count = 1
+        return format_convo(), "", "", current_topic
     
-    # Agent B responds to last message
+    # Critical Responder engages
     last_msg = conversation[-1]['text']
     b_msg = chat_completion(
         AGENT_B_PROMPT, 
-        [{"role": "user", "content": last_msg}]
+        [{"role": "user", "content": f"Topic: {current_topic}\n\nLast statement: {last_msg}"}]
     )
-    conversation.append({"agent": "Agent B", "text": b_msg})
-    embed_and_store(b_msg)
+    conversation.append({"agent": "🔍 Responder", "text": b_msg})
+    embed_and_store(b_msg, "Responder")
     
-    # Agent A responds to Agent B
+    # Initiator counters
     a_msg = chat_completion(
         AGENT_A_PROMPT, 
-        [{"role": "user", "content": b_msg}]
+        [{"role": "user", "content": f"Topic: {current_topic}\n\nCritical response: {b_msg}"}]
     )
-    conversation.append({"agent": "Agent A", "text": a_msg})
-    embed_and_store(a_msg)
+    conversation.append({"agent": "💡 Initiator", "text": a_msg})
+    embed_and_store(a_msg, "Initiator")
     
-    # Overseer intervention logic
-    intervention = None
-    if turn_count % 3 == 0 or detect_repetition():
+    # Overseer intervention
+    intervention = ""
+    if turn_count % 3 == 0 or detect_repetition() or detect_superficiality():
         context = "\n".join([m['text'] for m in conversation[-4:]])
-        prompt = f"Conversation Context:\n{context}\n\nIntervene to redirect or deepen the discussion:"
+        prompt = f"Topic: {current_topic}\n\nDiscussion Context:\n{context}\n\nDeepen the analysis:"
         intervention = chat_completion(OVERSEER_PROMPT, [{"role": "user", "content": prompt}])
-        conversation.append({"agent": "Overseer", "text": intervention})
-        embed_and_store(intervention)
+        conversation.append({"agent": "⚖️ Depth Guardian", "text": intervention})
+        embed_and_store(intervention, "Overseer")
+    
+    # Outsider commentary
+    outsider_msg = ""
+    if turn_count % 4 == 0 or "paradox" in last_msg.lower():
+        outsider_msg = outsider_comment()
+        conversation.append({"agent": "🌐 Provocateur", "text": outsider_msg})
+        embed_and_store(outsider_msg, "Outsider")
     
     turn_count += 1
-    return format_convo(), intervention or ""
+    return format_convo(), intervention, outsider_msg, current_topic
 
 # === OVERSEER QUERY HANDLER ===
 def overseer_respond(query):
     try:
-        # Add context from recent conversation
         context = "\n".join([m['text'] for m in conversation[-3:]]) if conversation else "No context"
-        messages = [
-            {"role": "user", "content": f"Recent conversation:\n{context}\n\nQuery: {query}"}
-        ]
+        messages = [{"role": "user", "content": f"Discussion Topic: {current_topic}\n\nRecent context:\n{context}\n\nQuery: {query}"}]
         return chat_completion(OVERSEER_PROMPT, messages)
     except Exception as e:
         return f"[Overseer Error: {str(e)}]"
@@ -179,7 +253,7 @@ def auto_loop():
     global auto_mode
     while auto_mode:
         step()
-        time.sleep(5)
+        time.sleep(6)
 
 def toggle_auto():
     global auto_mode
@@ -189,33 +263,62 @@ def toggle_auto():
     return "🔴 Auto: OFF" if not auto_mode else "🟢 Auto: ON"
 
 # === GRADIO UI ===
-with gr.Blocks() as demo:
-    gr.Markdown("# 🤖 Tri-Agent Conversational System")
-    gr.Markdown("**Agents**: A (Initiator) → B (Responder) → C (Overseer)")
+with gr.Blocks(title="Advanced Discussion Simulator") as demo:
+    gr.Markdown("# 🧠 Advanced Discussion Simulator")
+    gr.Markdown("### Quad-Agent System for Complex Discourse")
+    
+    with gr.Row():
+        topic_display = gr.Textbox(label="Current Topic", interactive=False)
     
     with gr.Row():
-        convo_display = gr.Markdown(value="**Conversation will appear here**")
+        convo_display = gr.Markdown(value="**Discussion will appear here**")
         
     with gr.Row():
-        step_btn = gr.Button("▶️ Next Conversation Step")
+        step_btn = gr.Button("▶️ Next Turn", variant="primary")
         auto_btn = gr.Button("🔴 Auto: OFF", variant="secondary")
-        clear_btn = gr.Button("🔄 Reset Conversation")
+        clear_btn = gr.Button("🔄 New Discussion", variant="stop")
+        topic_btn = gr.Button("🎲 Random Topic", variant="secondary")
     
-    with gr.Accordion("🧠 Overseer Query Panel", open=False):
-        gr.Markdown("Ask the Overseer (Agent C) for insights:")
-        qbox = gr.Textbox(label="Your Question", placeholder="What should we discuss next?")
-        overseer_out = gr.Textbox(label="Overseer's Response", interactive=False)
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### ⚖️ Depth Guardian")
+            intervention_display = gr.Textbox(label="Intervention", interactive=False)
+        with gr.Column(scale=1):
+            gr.Markdown("### 🌐 Cross-Disciplinary View")
+            outsider_display = gr.Textbox(label="Provocation", interactive=False)
+    
+    with gr.Accordion("💬 Guide the Discussion", open=False):
+        topic_input = gr.Textbox(label="Set Custom Topic", placeholder="e.g., Ethics of generative AI in creative industries...")
+        qbox = gr.Textbox(label="Ask the Depth Guardian", placeholder="What perspectives are missing in this discussion?")
+        overseer_out = gr.Textbox(label="Response", interactive=False)
     
     # Event handlers
     def clear_convo():
-        global conversation, turn_count
+        global conversation, turn_count, current_topic
         conversation = []
         turn_count = 0
-        return "**Conversation reset**", "🔴 Auto: OFF"
+        current_topic = ""
+        return "**New discussion started**", "", "", "", ""
+    
+    def new_topic():
+        clear_convo()
+        topic = generate_topic()
+        return "", "", "", topic, topic
     
-    step_btn.click(step, outputs=[convo_display, overseer_out])
+    step_btn.click(
+        step, 
+        inputs=[topic_input],
+        outputs=[convo_display, intervention_display, outsider_display, topic_display]
+    )
     qbox.submit(overseer_respond, inputs=qbox, outputs=overseer_out)
     auto_btn.click(toggle_auto, outputs=auto_btn)
-    clear_btn.click(clear_convo, outputs=[convo_display, auto_btn])
+    clear_btn.click(
+        clear_convo, 
+        outputs=[convo_display, intervention_display, outsider_display, topic_display, overseer_out]
+    )
+    topic_btn.click(
+        new_topic,
+        outputs=[convo_display, intervention_display, outsider_display, topic_display, overseer_out]
+    )
 
 demo.launch()