Update app.py

app.py

@@ -1,4 +1,5 @@
 import os
+import re
 import textwrap
 import traceback
 import gradio as gr
@@ -7,154 +8,221 @@ from openai import OpenAI
 # ---------------------------
 # Configuration
 # ---------------------------
-HF_ENV_VAR = "OPENAI_API_KEY"   # actually holds your Hugging Face token
+HF_ENV_VAR = "OPENAI_API_KEY"
 HF_TOKEN = os.environ.get(HF_ENV_VAR)
 if not HF_TOKEN:
-    print(
-        f"ERROR: environment variable {HF_ENV_VAR} not found. "
-        "Set it to your Hugging Face token before running."
+    raise RuntimeError(
+        f"Environment variable {HF_ENV_VAR} not found. Set {HF_ENV_VAR} before running."
     )
 
-MODEL_ID = "openai/gpt-oss-20b"  # served through Hugging Face router
-
-# ---------------------------
-# Initialize Hugging Face router client
-# ---------------------------
+MODEL_ID = "openai/gpt-oss-20b"
 client = OpenAI(base_url="https://router.huggingface.co/v1", api_key=HF_TOKEN)
 
 # ---------------------------
-# Research loader (project root)
+# Load research files (size-capped)
 # ---------------------------
-ROOT_DIR = "."
-ALLOWED_EXT = (".txt", ".md")
-
-def load_research_from_root(max_total_chars: int = 12000):
-    files = []
-    for name in sorted(os.listdir(ROOT_DIR)):
-        if name.lower().endswith(ALLOWED_EXT) and name != "requirements.txt":
-            if name == os.path.basename(__file__):
-                continue
-            files.append(name)
-
-    if not files:
-        return "No research files (.txt/.md) found in project root."
+MAX_RESEARCH_CHARS = 6000  # adjust to stay within token limits
 
-    combined_parts, total_len = [], 0
-    for fname in files:
-        try:
-            with open(os.path.join(ROOT_DIR, fname), "r", encoding="utf-8", errors="ignore") as f:
+def load_research_context() -> str:
+    """Concatenate .txt/.md files in repo root up to MAX_RESEARCH_CHARS."""
+    repo_root = os.path.dirname(os.path.abspath(__file__))
+    chunks, total = [], 0
+    for fname in sorted(os.listdir(repo_root)):
+        if fname.lower().endswith((".txt", ".md")):
+            with open(os.path.join(repo_root, fname), "r", encoding="utf-8") as f:
                 txt = f.read()
-        except Exception as e:
-            txt = f"[Error reading {fname}: {e}]"
-
-        if len(txt) > 8000:
-            sample = txt[:8000] + "\n\n[TRUNCATED]\n"
-        else:
-            sample = txt
-
-        part = f"--- {fname} ---\n{sample.strip()}\n"
-        combined_parts.append(part)
-        total_len += len(part)
-        if total_len >= max_total_chars:
-            break
-
-    combined = "\n\n".join(combined_parts)
-    if len(combined) > max_total_chars:
-        combined = combined[:max_total_chars] + "\n\n[TRUNCATED]"
-    return combined
+            if total + len(txt) > MAX_RESEARCH_CHARS:
+                txt = txt[: MAX_RESEARCH_CHARS - total]
+            chunks.append(f"\n--- {fname} ---\n{txt}")
+            total += len(txt)
+            if total >= MAX_RESEARCH_CHARS:
+                break
+    return "\n".join(chunks)
 
+RESEARCH_CONTEXT = load_research_context()
 
 # ---------------------------
-# System prompt templates
+# System prompt
 # ---------------------------
-research_context = load_research_from_root(max_total_chars=12000)
+def get_system_prompt(mode: str = "chat") -> str:
+    base = textwrap.dedent(f"""
+    You are Aerelyth, a Dialectical Agentic CrossSphere Intelligence AI.
 
-def get_system_prompt(mode="chat"):
-    if mode == "chat":
-        return textwrap.dedent(f"""
-      OhamLab A Quantum  Intelligence AI.
-        Mode: Conversational.
-        Guidelines:
-        - Answer clearly in natural paragraphs (3–6 sentences).
-        - Do NOT use tables, spreadsheets, or rigid formatting unless explicitly asked.
-        - Always address the user’s question directly before expanding.
-        - Be insightful, empathetic, and concise.
+    IMPORTANT GUIDELINES:
+    - Deliver a complete, self-contained answer in one message whenever possible.
+    - If the user types "continue", resume exactly where you left off and DO NOT repeat previously provided text.
+    - NEVER include runnable code blocks, scripts, or function/class definitions unless the user explicitly asks.
+    - If code is requested, ask one clarifying question if needed, then provide code.
+    - Express algorithms in plain English unless code is explicitly requested.
+    - If uncertain, label speculation and state confidence.
 
-        --- BEGIN RESEARCH CONTEXT (TRIMMED) ---
-        {research_context}
-        --- END RESEARCH CONTEXT ---
-        """).strip()
-    else:
-        return textwrap.dedent(f"""
-        You are OhamLab, a Quantum Dialectical Agentic Crosssphere Intelligence AI.
-        Mode: Research / Analytical.
-        Guidelines:
-        - Write structured, multi-sphere reasoning (science, philosophy, psychology, etc).
-        - Use sections, subpoints, and dialectical chains.
-        - Provide deep analysis, even if it looks like a research paper.
-        - Always reference the research context if relevant.
-
-        --- BEGIN RESEARCH CONTEXT (TRIMMED) ---
-        {research_context}
-        --- END RESEARCH CONTEXT ---
-        """).strip()
+    Mode: {mode}
+    --- RESEARCH CONTEXT (TRIMMED) ---
+    {RESEARCH_CONTEXT}
+    --- END CONTEXT ---
+    """).strip()
+    return base
 
 # ---------------------------
-# State
+# Conversation state
 # ---------------------------
-conversation_mode = "chat"  # can toggle
+conversation_mode = "chat"
 history_messages = [{"role": "system", "content": get_system_prompt("chat")}]
 chat_history_for_ui = []
+MAX_HISTORY_CHARS = 9000
+
+def trim_history_by_chars(msgs, max_chars=MAX_HISTORY_CHARS):
+    if not msgs:
+        return msgs
+    system = msgs[0]
+    tail, total = [], len(system["content"])
+    for m in reversed(msgs[1:]):
+        seg_len = len(m.get("content", ""))
+        if total + seg_len > max_chars:
+            break
+        tail.append(m)
+        total += seg_len
+    return [system] + list(reversed(tail))
+
+# ---------------------------
+# Code-detection utilities
+# ---------------------------
+CODE_PATTERN = re.compile(
+    r"(```|```[a-zA-Z]*|^\s*def\s+|^\s*class\s+|^\s*import\s+|#include\s+|<\?php|<html>|^\s*using\s+namespace)",
+    re.MULTILINE,
+)
+
+def is_code_like(text: str) -> bool:
+    if not text:
+        return False
+    if CODE_PATTERN.search(text):
+        return True
+    lines = [ln for ln in text.splitlines() if ln.strip()]
+    if len(lines) >= 4:
+        codey = sum(
+            1 for ln in lines
+            if ";" in ln or "{" in ln or "}" in ln or ln.strip().endswith(":")
+        )
+        return codey / len(lines) > 0.35
+    return False
+
+def strip_code_blocks(text: str) -> str:
+    text = re.sub(r"```.*?```", "", text, flags=re.DOTALL)
+    text_lines = []
+    for ln in text.splitlines():
+        if re.match(r"^\s*(def |class |import |from |#include|using |<)", ln):
+            continue
+        if ln.strip().startswith("```") or ln.strip().endswith("```"):
+            continue
+        text_lines.append(ln)
+    cleaned = "\n".join(text_lines).strip()
+    return re.sub(r"\n{3,}", "\n\n", cleaned) or \
+        "[Content removed: model produced code which has been stripped.]"
 
 # ---------------------------
 # Model call helper
 # ---------------------------
-def call_model_get_response(model_id: str, messages: list, max_tokens: int = 700):
-    resp = client.chat.completions.create(
-        model=model_id,
-        messages=messages,
-        max_tokens=max_tokens,
-        temperature=0.7,
-    )
-    choice = resp.choices[0]
+def call_model_get_response(messages, max_tokens=2000, allow_code=False) -> str:
+    msgs = trim_history_by_chars(messages)
     try:
-        return choice.message.content.strip()
-    except Exception:
-        return str(choice)
+        resp = client.chat.completions.create(
+            model=MODEL_ID,
+            messages=msgs,
+            max_tokens=max_tokens,
+            temperature=0.7,
+        )
+        content = resp.choices[0].message.content or ""
+    except Exception as e:
+        raise
+
+    if not allow_code and is_code_like(content):
+        rewrite_instruction = (
+            "Rewrite the previous reply in clear prose — no code blocks, no imports, "
+            "no function/class definitions. Keep all reasoning and numeric details."
+        )
+        rewrite_msgs = [
+            msgs[0],
+            {"role": "assistant", "content": content},
+            {"role": "user", "content": rewrite_instruction},
+        ]
+        try:
+            resp2 = client.chat.completions.create(
+                model=MODEL_ID,
+                messages=rewrite_msgs,
+                max_tokens=max_tokens,
+                temperature=0.7,
+            )
+            content2 = resp2.choices[0].message.content or ""
+        except Exception:
+            return strip_code_blocks(content) + \
+                "\n\n⚠️ Note: rewrite failed; code removed."
+        if is_code_like(content2):
+            return strip_code_blocks(content2) + \
+                "\n\n⚠️ Note: model persisted in producing code; sanitized."
+        return content2
+    return content
 
 # ---------------------------
 # Chat logic
 # ---------------------------
+def get_last_assistant_tail(max_chars=1200) -> str:
+    for m in reversed(history_messages):
+        if m["role"] == "assistant" and m.get("content"):
+            return m["content"][-max_chars:]
+    return ""
+
+CONTINUE_KEYWORDS = {"continue", "carry on", "go on", "proceed", "resume", "next"}
+def user_requested_code(user_text: str) -> bool:
+    t = (user_text or "").lower()
+    triggers = ["show code", "give me code", "provide code",
+                "script", "python", "javascript", "implementation"]
+    return any(k in t for k in triggers)
+
 def chat_with_model(user_message, chat_history):
     global history_messages, chat_history_for_ui, conversation_mode
+    user_message = (user_message or "").strip()
+    if not user_message:
+        return chat_history, ""
 
-    if not user_message or str(user_message).strip() == "":
-        return "", chat_history
+    lower = user_message.lower().strip()
 
-    # Mode switching commands
-    if "switch to research mode" in user_message.lower():
+    # Mode switching
+    if "switch to research mode" in lower:
         conversation_mode = "research"
-        history_messages = [{"role": "system", "content": get_system_prompt("research")}]
-        return "", chat_history + [("🟢 Mode switched", "🔬 Research Mode activated.")]
-    elif "switch to chat mode" in user_message.lower():
+        history_messages = [{"role": "system",
+                             "content": get_system_prompt("research")}]
+        return chat_history + [("🟢 Mode switched", "🔬 Research Mode activated.")], ""
+    if "switch to chat mode" in lower:
         conversation_mode = "chat"
-        history_messages = [{"role": "system", "content": get_system_prompt("chat")}]
-        return "", chat_history + [("🟢 Mode switched", "💬 Chat Mode activated.")]
+        history_messages = [{"role": "system",
+                             "content": get_system_prompt("chat")}]
+        return chat_history + [("🟢 Mode switched", "💬 Chat Mode activated.")], ""
+
+    allow_code = user_requested_code(user_message)
+    if lower in CONTINUE_KEYWORDS:
+        last_tail = get_last_assistant_tail()
+        resume_hint = (
+            "User requested continuation. Resume exactly where you left off "
+            "and DO NOT repeat earlier sections.\n\nLast assistant message tail:\n"
+            + last_tail
+        )
+        history_messages.append({"role": "user", "content": resume_hint})
+    else:
+        history_messages.append({"role": "user", "content": user_message})
 
-    # Append user message
-    history_messages.append({"role": "user", "content": user_message})
+    history_messages[:] = trim_history_by_chars(history_messages)
 
     try:
-        bot_text = call_model_get_response(MODEL_ID, history_messages, max_tokens=700)
+        bot_text = call_model_get_response(
+            history_messages, max_tokens=2000, allow_code=allow_code
+        )
     except Exception as e:
         tb = traceback.format_exc()
-        bot_text = f"⚠️ **Error**: {str(e)}\n\nTraceback:\n{tb.splitlines()[-6:]}"
+        bot_text = f"⚠️ **Error**: {e}\n\nTraceback:\n{tb.splitlines()[-6:]}"
 
-    # Append response
     history_messages.append({"role": "assistant", "content": bot_text})
     chat_history_for_ui.append((user_message, bot_text))
-
-    return "", chat_history_for_ui
+    return chat_history_for_ui, ""
 
 def reset_chat():
     global history_messages, chat_history_for_ui
@@ -163,85 +231,38 @@ def reset_chat():
     return []
 
 # ---------------------------
-# Gradio UI
+# Gradio UI with working Send button
 # ---------------------------
 def build_ui():
-    with gr.Blocks(
-        theme=gr.themes.Soft(),
-        css="""
-        #chatbot {
-            background-color: #f9f9fb;
-            border-radius: 12px;
-            padding: 10px;
-            overflow-y: auto;
-        }
-        .user-bubble {
-            background: #4a90e2;
-            color: white;
-            border-radius: 14px;
-            padding: 8px 12px;
-            margin: 6px;
-            max-width: 75%;
-            align-self: flex-end;
-            font-size: 14px;
-        }
-        .bot-bubble {
-            background: #e6e6e6;
-            color: #333;
-            border-radius: 14px;
-            padding: 8px 12px;
-            margin: 6px;
-            max-width: 75%;
-            align-self: flex-start;
-            font-size: 14px;
-        }
-        #controls {
-            display: flex;
-            gap: 8px;
-            align-items: center;
-            margin-top: 6px;
-        }
-        #topbar {
-            display: flex;
-            justify-content: flex-end;
-            gap: 8px;
-            margin-bottom: 6px;
-        }
-        """
-    ) as demo:
-        # Top bar with close + clear
-        with gr.Row(elem_id="topbar"):
-            close_btn = gr.Button("❌", size="sm")
-            clear_btn = gr.Button("🧹 Clear", size="sm")
-
-        chatbot = gr.Chatbot(
-            label="",
-            height=350,   # reduced height so input is visible
-            elem_id="chatbot",
-            type="tuples",
-            bubble_full_width=False,
-            avatar_images=("👤", "🤖"),
-        )
+    custom_css = """
+    #chatbot { background-color:#11121a; color:#e6eef8;
+               border-radius:10px; padding:10px; }
+    """
+    with gr.Blocks(theme=gr.themes.Soft(), css=custom_css) as demo:
+        gr.Markdown("## 🤖 Aerelyth — Dialectical Agentic CrossSphere AI")
+        chatbot = gr.Chatbot(height=520, elem_id="chatbot", type="tuples")
 
-        with gr.Row(elem_id="controls"):
+        with gr.Row():
             msg = gr.Textbox(
-                placeholder="Type your message here...",
-                lines=2,
+                placeholder="Type message (press Enter or click Send)…",
+                lines=3,
                 scale=8,
+                show_label=False
             )
-            submit_btn = gr.Button("🚀 Send", variant="primary", scale=2)
+            send = gr.Button("Send", variant="primary", scale=1)
+
+        with gr.Row():
+            clear = gr.Button("Clear")
 
-        # Wire buttons
-        submit_btn.click(chat_with_model, inputs=[msg, chatbot], outputs=[msg, chatbot])
-        msg.submit(chat_with_model, inputs=[msg, chatbot], outputs=[msg, chatbot])
-        clear_btn.click(reset_chat, inputs=None, outputs=chatbot)
+        send.click(chat_with_model, inputs=[msg, chatbot], outputs=[chatbot, msg])
+        msg.submit(chat_with_model, inputs=[msg, chatbot], outputs=[chatbot, msg])
+        clear.click(reset_chat, outputs=chatbot)
 
         demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
-    return demo
 
 # ---------------------------
 # Entrypoint
 # ---------------------------
 if __name__ == "__main__":
-    print(f"✅ Starting Aerelyth with Hugging Face model: {MODEL_ID}")
+    print("Starting Aerelyth with size-capped research context…")
     build_ui()