Update app.py

app.py

@@ -188,12 +188,7 @@ def retrieve_relevant_memory(query, k=3):
         print(f"Memory retrieval error: {str(e)}")
         return []
 
-# ... [Rest of the functions remain the same as previous implementation] ...
-# Keep all the functions from the previous implementation except:
-# - safe_chat_completion (already replaced above)
-# - get_embedding (already replaced above)
-
-# ... [Keep all imports, config, and function definitions above] ...
+# ... [Previous code remains unchanged] ...
 
 # === GRADIO UI ===
 with gr.Blocks(theme=gr.themes.Soft(), title="DeepSeek Discussion Platform") as demo:
@@ -221,6 +216,12 @@ with gr.Blocks(theme=gr.themes.Soft(), title="DeepSeek Discussion Platform") as
             elem_id="convo-display"
         )
         
+        # Placeholder displays for agent-specific content
+        intervention_display = gr.Textbox(label="Depth Guardian Intervention", visible=False)
+        outsider_display = gr.Textbox(label="Cross-Disciplinary Provocateur", visible=False)
+        cultural_display = gr.Textbox(label="Cultural Perspective", visible=False)
+        judge_display = gr.Textbox(label="Judge's Ruling", visible=False)
+        
         with gr.Row():
             step_btn = gr.Button("▶️ Next Turn", variant="primary")
             auto_btn = gr.Button("🔴 Auto: OFF", variant="secondary")
@@ -236,390 +237,54 @@ with gr.Blocks(theme=gr.themes.Soft(), title="DeepSeek Discussion Platform") as
             with gr.Row():
                 overseer_out = gr.Textbox(label="Depth Guardian Response", interactive=False)
                 judge_out = gr.Textbox(label="Judge's Response", interactive=False)
+            submit_btn = gr.Button("💬 Add User Contribution", variant="primary")
+            user_input = gr.Textbox(label="Your Contribution", placeholder="Add your perspective to the discussion...")
+            user_feedback = gr.Textbox(label="Feedback", interactive=False, visible=False)
     
-# === COMPLETE IMPLEMENTATION ===
-
-def overseer_respond(question, conversation, current_topic):
-    """Get response from Depth Guardian"""
-    context = f"Current Topic: {current_topic}\n\n" if current_topic else ""
-    context += "Conversation History:\n"
-    for msg in conversation[-5:]:
-        context += f"- {msg['agent']}: {msg['text']}\n"
-    
-    response = safe_chat_completion(
-        system=OVERSEER_PROMPT,
-        messages=[{"role": "user", "content": f"{context}\nQuestion: {question}"}],
-        temperature=0.8
-    )
-    embed_and_store(response, "Guardian")
-    return response
-
-def ask_judge(question, conversation, current_topic):
-    """Get ruling from Judge"""
-    context = f"Topic: {current_topic}\n\n" if current_topic else ""
-    context += "Recent Discussion:\n"
-    for msg in conversation[-5:]:
-        context += f"- {msg['agent']}: {msg['text']}\n"
-    
-    response = safe_chat_completion(
-        system=JUDGE_PROMPT,
-        messages=[{"role": "user", "content": f"{context}\nSpecific Question: {question}"}],
-        temperature=0.6
-    )
-    
-def step(topic_input, conversation, turn_count, current_topic, last_ruling_turn, agent_params):
-    """Advance the discussion by one turn"""
-    # Remove global declarations - we'll use the parameters directly
-    # Set topic on first turn
-    if turn_count == 0:
-        if topic_input.strip():
-            current_topic = topic_input.strip()
-        else:
-            current_topic = "Ethical Implications of Advanced AI Systems"
-    
-    # Determine which agent speaks
-    agent_sequence = ["Initiator", "Responder", "Guardian", "Provocateur", "Cultural"]
-    agent_index = turn_count % len(agent_sequence)
-    agent_name = agent_sequence[agent_index]
-    
-    # Special handling for Judge
-    judge_interval = 5
-    if turn_count - last_ruling_turn >= judge_interval and turn_count > 0:
-        agent_name = "Judge"
-    
-    # Get system prompt and temperature
-    prompts = {
-        "Initiator": AGENT_A_PROMPT,
-        "Responder": AGENT_B_PROMPT,
-        "Guardian": OVERSEER_PROMPT,
-        "Provocateur": OUTSIDER_PROMPT,
-        "Cultural": CULTURAL_LENS_PROMPT,
-        "Judge": JUDGE_PROMPT
-    }
-    temperature = agent_params[agent_name]["creativity"]
-    
-    # Prepare context
-    context = f"Current Topic: {current_topic}\n\nDiscussion History:\n"
-    for msg in conversation[-5:]:
-        context += f"{msg['agent']}: {msg['text']}\n\n"
-    
-    # Generate response
-    response = safe_chat_completion(
-        system=prompts[agent_name],
-        messages=[{"role": "user", "content": context}],
-        temperature=temperature
-    )
-    
-    # Create message entry
-    new_entry = {
-        "agent": agent_name,
-        "text": response,
-        "turn": turn_count + 1
-    }
-    
-    # Update state
-    updated_conversation = conversation + [new_entry]
-    new_turn_count = turn_count + 1
-    new_last_ruling_turn = new_turn_count if agent_name == "Judge" else last_ruling_turn
-    
-    # Update memory
-    embed_and_store(response, agent_name, current_topic)  # Pass current_topic here
-    
-    # Format HTML output
-    html_output = format_conversation_html(updated_conversation)
-    
-    # Get agent-specific displays
-    intervention = get_last_by_agent(updated_conversation, "Guardian")
-    outsider = get_last_by_agent(updated_conversation, "Provocateur")
-    cultural = get_last_by_agent(updated_conversation, "Cultural")
-    judge = get_last_by_agent(updated_conversation, "Judge")
-    
-    # Prepare agent status
-    active_agents = " | ".join([f"{agent}: {entry['text'][:30]}..." for agent, entry in zip(
-        ["Initiator", "Responder", "Guardian", "Provocateur", "Cultural", "Judge"],
-        [new_entry] * 6  # Simplified for demo
-    )])
-    
-    return (
-        html_output,
-        intervention,
-        outsider,
-        cultural,
-        judge,
-        current_topic,
-        new_turn_count,
-        active_agents,
-        updated_conversation,
-        new_turn_count,
-        current_topic,
-        new_last_ruling_turn,
-        agent_params
-    )
-
-# Update embed_and_store to accept topic as parameter
-def embed_and_store(text, agent=None, topic=""):
-    """Store text with associated topic"""
-    try:
-        vec = get_embedding(text)
-        memory_index.add(np.array([vec], dtype='float32'))
-        memory_data.append({
-            "text": text,
-            "timestamp": datetime.now().isoformat(),
-            "agent": agent or "system",
-            "topic": topic
-        })
-        if len(memory_data) % 5 == 0:
-            with open(MEMORY_FILE, "wb") as f:
-                pickle.dump(memory_data, f)
-            faiss.write_index(memory_index, INDEX_FILE)
-    except Exception as e:
-        print(f"Memory Error: {str(e)}")
-
-# ... [Rest of the functions remain unchanged] ...
-def get_last_by_agent(conversation, agent_name):
-    """Get last message from specific agent"""
-    for msg in reversed(conversation):
-        if msg["agent"] == agent_name:
-            return msg["text"]
-    return "No message yet"
-
-def format_conversation_html(conversation):
-    """Format conversation as HTML"""
-    html = "<div class='convo-container'>"
-    for msg in conversation:
-        agent = msg["agent"]
-        color_map = {
-            "Initiator": "#e6f7ff",
-            "Responder": "#f6ffed",
-            "Guardian": "#fff7e6",
-            "Provocateur": "#f9e6ff",
-            "Cultural": "#e6ffed",
-            "Judge": "#f0f0f0",
-            "User": "#f0f0f0"
-        }
-        color = color_map.get(agent, "#ffffff")
-        html += f"""
-        <div style='background:{color}; padding:10px; margin:10px; border-radius:5px;'>
-            <b>{agent}:</b> {msg['text']}
-        </div>
-        """
-    html += "</div>"
-    return html
-
-def toggle_auto(auto_mode):
-    """Toggle auto-advance mode"""
-    new_mode = not auto_mode
-    return ("🟢 Auto: ON" if new_mode else "🔴 Auto: OFF", new_mode)
-
-def clear_convo():
-    """Reset conversation"""
-    global conversation, turn_count, current_topic, last_ruling_turn
-    conversation = []
-    turn_count = 0
-    current_topic = ""
-    last_ruling_turn = 0
-    return (
-        format_conversation_html([]),
-        "",
-        "",
-        "",
-        "",
-        "",
-        0,
-        "💡 Initiator, 🔍 Responder",
-        [],
-        0,
-        "",
-        0,
-        "",
-        ""
-    )
-
-def new_topic(conversation, turn_count, current_topic):
-    """Generate a new discussion topic"""
-    # In a real implementation, this would call an LLM to generate a topic
-    topics = [
-        "The Ethics of Genetic Engineering in Humans",
-        "Universal Basic Income in the Age of Automation",
-        "Cultural Impacts of Global AI Deployment",
-        "Privacy vs Security in Digital Societies",
-        "The Future of Human-AI Collaboration"
-    ]
-    new_topic = np.random.choice(topics)
-    return (
-        format_conversation_html([]),
-        new_topic,
-        0,
-        [],
-        0,
-        new_topic
-    )
-
-def request_ruling(conversation, current_topic, turn_count, last_ruling_turn):
-    """Request a ruling from the Judge"""
-    context = f"Topic: {current_topic}\n\nDiscussion Summary:\n"
-    for msg in conversation[-5:]:
-        context += f"- {msg['agent']}: {msg['text']}\n"
-    
-    response = safe_chat_completion(
-        system=JUDGE_PROMPT,
-        messages=[{"role": "user", "content": f"{context}\nPlease provide a comprehensive ruling."}],
-        temperature=0.5
-    )
-    
-    new_entry = {
-        "agent": "Judge",
-        "text": response,
-        "turn": turn_count
-    }
-    updated_conversation = conversation + [new_entry]
-    return response, updated_conversation, turn_count
-
-def run_analysis(conversation):
-    """Run basic analysis (simplified for free version)"""
-    # Sentiment analysis placeholder
-    sentiments = ["Positive", "Neutral", "Negative"]
-    sentiment_result = np.random.choice(sentiments, p=[0.4, 0.4, 0.2])
-    
-    # Topic extraction placeholder
-    topics = ["AI Ethics", "Policy", "Cultural Impact", "Technology", "Future Scenarios"]
-    topic_result = ", ".join(np.random.choice(topics, 3, replace=False))
-    
-    # Agent participation plot
-    agents = [msg["agent"] for msg in conversation]
-    if agents:
-        agent_counts = {agent: agents.count(agent) for agent in set(agents)}
-        plt.figure(figsize=(8, 4))
-        plt.bar(agent_counts.keys(), agent_counts.values())
-        plt.title("Agent Participation")
-        plt.ylabel("Number of Messages")
-        plt.tight_layout()
-        plt.savefig("agent_plot.png")
-        plot_path = "agent_plot.png"
-    else:
-        plot_path = None
-    
-    return (
-        f"Overall Sentiment: {sentiment_result}",
-        f"Key Topics: {topic_result}",
-        plot_path
-    )
-
-def generate_knowledge_graph(conversation):
-    """Generate a simple knowledge graph (placeholder)"""
-    G = nx.DiGraph()
-    entities = ["AI", "Ethics", "Society", "Technology", "Future"]
-    for i, e1 in enumerate(entities):
-        for j, e2 in enumerate(entities):
-            if i != j and np.random.random() > 0.7:
-                G.add_edge(e1, e2, weight=np.random.random())
-    
-    plt.figure(figsize=(10, 8))
-    pos = nx.spring_layout(G)
-    nx.draw(G, pos, with_labels=True, node_size=2000, 
-            node_color="skyblue", font_size=10, 
-            edge_color="gray", width=1.5)
-    plt.title("Knowledge Graph")
-    plt.savefig("knowledge_graph.png")
-    return "knowledge_graph.png"
-
-def export_handler(format_radio, conversation, current_topic, turn_count):
-    """Export conversation in various formats"""
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    
-    if format_radio == "txt":
-        filename = f"discussion_{timestamp}.txt"
-        with open(filename, "w") as f:
-            f.write(f"Topic: {current_topic}\nTurns: {turn_count}\n\n")
-            for msg in conversation:
-                f.write(f"{msg['agent']} (Turn {msg.get('turn', 'N/A')}):\n{msg['text']}\n\n")
-        return filename
-    
-    elif format_radio == "pdf":
-        filename = f"discussion_{timestamp}.pdf"
-        doc = SimpleDocTemplate(filename, pagesize=letter)
-        styles = getSampleStyleSheet()
-        story = []
-        
-        story.append(Paragraph(f"Discussion: {current_topic}", styles["Title"]))
-        story.append(Paragraph(f"Turns: {turn_count}", styles["Normal"]))
-        story.append(Spacer(1, 12))
+    # Analysis tab
+    with gr.Tab("Analysis"):
+        with gr.Row():
+            sentiment_display = gr.Textbox(label="Sentiment Analysis", interactive=False)
+            topics_display = gr.Textbox(label="Key Topics", interactive=False)
+        agent_plot = gr.Image(label="Agent Participation")
+        graph_display = gr.Image(label="Knowledge Graph")
+        analysis_btn = gr.Button("📊 Run Analysis", variant="primary")
+        graph_btn = gr.Button("🌐 Generate Knowledge Graph", variant="secondary")
+    
+    # Export tab
+    with gr.Tab("Export"):
+        format_radio = gr.Radio(
+            choices=["txt", "pdf", "json"], 
+            label="Export Format", 
+            value="txt"
+        )
+        export_btn = gr.Button("💾 Export Discussion", variant="primary")
+        export_result = gr.File(label="Export Result", interactive=False)
         
-        for msg in conversation:
-            agent_text = f"<b>{msg['agent']}</b> (Turn {msg.get('turn', 'N/A')}):"
-            story.append(Paragraph(agent_text, styles["Normal"]))
-            story.append(Paragraph(msg["text"], styles["BodyText"]))
-            story.append(Spacer(1, 12))
+        gr.Markdown("### Webhook Integration")
+        webhook_url = gr.Textbox(label="Webhook URL", placeholder="https://your-webhook-endpoint.com")
+        integrate_btn = gr.Button("🔌 Send to Webhook", variant="secondary")
+        integration_status = gr.Textbox(label="Status", interactive=False)
+    
+    # Agent Configuration tab
+    with gr.Tab("Configuration"):
+        gr.Markdown("### Agent Parameters")
+        agent_sliders = {}
+        agents = ["Initiator", "Responder", "Guardian", "Provocateur", "Cultural", "Judge"]
+        params = ["creativity", "criticality"]
         
-        doc.build(story)
-        return filename
+        for agent in agents:
+            with gr.Accordion(f"{agent} Settings", open=False):
+                for param in params:
+                    slider = gr.Slider(
+                        minimum=0.0, 
+                        maximum=1.0, 
+                        step=0.05,
+                        label=f"{agent} {param.capitalize()}",
+                        value=agent_params[agent][param]
+                    )
+                    agent_sliders[f"{agent}_{param}"] = slider
     
-    elif format_radio == "json":
-        filename = f"discussion_{timestamp}.json"
-        data = {
-            "topic": current_topic,
-            "turns": turn_count,
-            "conversation": conversation
-        }
-        with open(filename, "w") as f:
-            json.dump(data, f, indent=2)
-        return filename
-    
-    return "export_error.txt"
-
-def send_to_webhook(webhook_url, conversation, current_topic, turn_count):
-    """Send conversation to webhook"""
-    if not webhook_url.startswith("http"):
-        return "⚠️ Invalid URL"
-    
-    payload = {
-        "topic": current_topic,
-        "turns": turn_count,
-        "conversation": conversation
-    }
-    
-    try:
-        response = requests.post(webhook_url, json=payload, timeout=10)
-        if response.status_code == 200:
-            return "✅ Sent successfully!"
-        return f"⚠️ Error: {response.status_code} - {response.text}"
-    except Exception as e:
-        return f"⚠️ Connection error: {str(e)}"
-
-def add_user_contribution(user_input, conversation):
-    """Add user contribution to conversation"""
-    if not user_input.strip():
-        return format_conversation_html(conversation), "Please enter a message", conversation
-    
-    new_entry = {
-        "agent": "User",
-        "text": user_input,
-        "turn": len(conversation) + 1
-    }
-    updated_conversation = conversation + [new_entry]
-    embed_and_store(user_input, "User")
-    return format_conversation_html(updated_conversation), "✅ Added your contribution!", updated_conversation
-
-def update_agent_params(*args):
-    """Update agent parameters from sliders"""
-    # Last argument is the current params state
-    current_params = args[-1]
-    sliders = args[:-1]
-    
-    # Map sliders to agent parameters
-    agents = ["Initiator", "Responder", "Guardian", "Provocateur", "Cultural", "Judge"]
-    params = ["creativity", "criticality"]
-    
-    updated_params = {}
-    slider_index = 0
-    for agent in agents:
-        updated_params[agent] = {}
-        for param in params:
-            updated_params[agent][param] = sliders[slider_index]
-            slider_index += 1
-    
-    return updated_params
-
     # Custom CSS
     demo.css = """
     .convo-container {
@@ -671,12 +336,28 @@ def update_agent_params(*args):
     
     step_btn.click(
         step, 
-        inputs=[topic_input, conversation_state, turn_count_state, current_topic_state, last_ruling_turn_state, agent_params_state],
+        inputs=[
+            topic_input, 
+            conversation_state, 
+            turn_count_state, 
+            current_topic_state, 
+            last_ruling_turn_state, 
+            agent_params_state
+        ],
         outputs=[
-            convo_display, intervention_display, outsider_display, 
-            cultural_display, judge_display, topic_display, turn_counter, 
-            agent_status, conversation_state, turn_count_state, current_topic_state,
-            last_ruling_turn_state
+            convo_display, 
+            intervention_display, 
+            outsider_display, 
+            cultural_display, 
+            judge_display, 
+            topic_display, 
+            turn_counter, 
+            agent_status, 
+            conversation_state, 
+            turn_count_state, 
+            current_topic_state,
+            last_ruling_turn_state,
+            agent_params_state
         ]
     )
     
@@ -689,19 +370,35 @@ def update_agent_params(*args):
     clear_btn.click(
         clear_convo, 
         outputs=[
-            convo_display, intervention_display, outsider_display, 
-            cultural_display, judge_display, topic_display, turn_counter,
-            agent_status, conversation_state, turn_count_state, current_topic_state,
-            last_ruling_turn_state, overseer_out, judge_out
+            convo_display, 
+            intervention_display, 
+            outsider_display, 
+            cultural_display, 
+            judge_display, 
+            topic_display, 
+            turn_counter,
+            agent_status, 
+            conversation_state, 
+            turn_count_state, 
+            current_topic_state,
+            last_ruling_turn_state, 
+            overseer_out, 
+            judge_out,
+            agent_params_state
         ]
     )
     
     topic_btn.click(
         new_topic,
-        inputs=[conversation_state, turn_count_state, current_topic_state],
+        inputs=[conversation_state, turn_count_state, current_topic_state, last_ruling_turn_state],
         outputs=[
-            convo_display, topic_display, turn_counter, conversation_state, 
-            turn_count_state, current_topic_state
+            convo_display, 
+            topic_display, 
+            turn_counter, 
+            conversation_state, 
+            turn_count_state, 
+            current_topic_state,
+            last_ruling_turn_state
         ]
     )
     
@@ -741,20 +438,10 @@ def update_agent_params(*args):
         outputs=[convo_display, user_feedback, conversation_state]
     )
     
-    voting_btn.click(
-        lambda: "✅ Your vote has been recorded!",
-        outputs=[user_feedback]
-    )
-    
-    flag_btn.click(
-        lambda: "🚩 Issue flagged for moderator review",
-        outputs=[user_feedback]
-    )
-    
     # Create input list for slider change events
     slider_inputs = [agent_sliders[f"{agent}_{param}"] 
-                    for agent in ["Initiator", "Responder", "Guardian", "Provocateur", "Cultural", "Judge"]
-                    for param in ["creativity", "critical"]]
+                    for agent in agents
+                    for param in params]
     
     for slider in slider_inputs:
         slider.change(