update app, storage, core_logic, requirements

app.py

@@ -5,56 +5,61 @@
 The Interface Skeleton - The code sets up the navigation panel and the multimodal chat interface
 """
 
+
 import gradio as gr
 from core_logic import chat_function
-from storage import save_chat, load_history
-
-with gr.Blocks(css="styles.css", theme=gr.themes.Soft()) as demo:
-    # State variables for persistence
-    current_chat_id = gr.State("")
-    session_history = gr.State([])
+from storage import save_chat, load_history, get_chat_content
 
+with gr.Blocks() as demo:
+    chat_id_state = gr.State("")
+    
     with gr.Row():
-        # --- SIDEBAR (Navigation Panel) ---
+        # --- Sidebar ---
         with gr.Column(scale=1, variant="secondary"):
-            gr.Markdown("## 🛠️ Agent Architect")
+            gr.Markdown("### 🛠️ Silicon Architect")
             new_btn = gr.Button("➕ New Chat", variant="primary")
             
-            gr.Markdown("### 🕒 Recent Conversations")
-            # This would be populated from storage.py
             history_list = gr.Dataset(
                 components=[gr.Textbox(visible=False)], 
-                label="", 
+                label="Recent Conversations", 
                 samples=load_history()
             )
             
-            gr.Markdown("---")
-            download_format = gr.Radio([".txt", ".pdf", ".docx"], label="Export Format")
-            export_btn = gr.Button("📥 Download Current Chat")
-
-        # --- MAIN CHAT INTERFACE ---
+        # --- Main Chat ---
         with gr.Column(scale=4):
+            # Gradio 6: 'type' is removed, 'messages' is default
             chatbot = gr.Chatbot(
                 show_label=False, 
-                elem_id="chat-window", 
-                height=750,
-                type="messages",
-                multimodal=True
+                height=700, 
+                multimodal=True,
+                autoscroll=True
             )
             
-            with gr.Row():
-                user_input = gr.MultimodalTextbox(
-                    show_label=False,
-                    placeholder="Describe your agentic architecture or upload code...",
-                    file_types=[".py", ".pdf", ".js", ".md", ".txt", ".docx"],
-                    file_count="multiple"
-                )
+            chat_input = gr.MultimodalTextbox(
+                interactive=True,
+                placeholder="Discuss architecture or upload code...",
+                show_label=False
+            )
 
-    # --- EVENT HANDLERS ---
-    def handle_user_msg(message, history):
-        # This will link to our core_logic.py
-        return chat_function(message, history)
+    # --- Event Logic ---
+    def bot_response(message, history):
+        # chat_function yields strings; we must return the updated history dict
+        history.append({"role": "user", "content": message["text"]})
+        # Placeholder for assistant message
+        history.append({"role": "assistant", "content": ""})
+        
+        for partial_resp in chat_function(message, history[:-2]):
+            history[-1]["content"] = partial_resp
+            yield history
 
-    user_input.submit(handle_user_msg, [user_input, chatbot], [user_input, chatbot])
+    chat_input.submit(bot_response, [chat_input, chatbot], [chatbot]).then(
+        lambda h: save_chat(None, h), [chatbot], None
+    )
     
-demo.launch()
+    new_btn.click(lambda: ([], ""), None, [chatbot, chat_id_state])
+
+# Move theme and CSS here for Gradio 6.0
+demo.launch(
+    theme=gr.themes.Soft(),
+    css="styles.css"
+)

core_logic.py

@@ -17,6 +17,9 @@ SYSTEM_PROMPT = """
 You are the 'Silicon Architect'—a master-stroke creative genius in AI Engineering and Technical Architecture. 
 Your goal is to provide production-grade, highly optimized solutions for web and mobile AI applications.
 
+Expertise: Python 3.12, Agentic Loops, FastAPI, and Scalable Architecture. 
+Provide production-ready code and rigorous technical research.
+
 CORE DIRECTIVES:
 1. ARCHITECTURAL RIGOR: Always consider scalability, async patterns, and state management.
 2. AGENTIC EXPERTISE: You understand recurrent-depth simulations, tool-calling, and autonomous loops.
@@ -28,41 +31,33 @@ When a user provides files, analyze the code structure and logic before proposin
 """
 
 def chat_function(message, history):
-    # 1. Handle Multimodal Input (Files)
-    files_content = ""
-    user_text = message["text"]
+    # message is now a dict: {"text": "...", "files": [...]}
+    user_text = message.get("text", "")
+    files = message.get("files", [])
     
-    if message["files"]:
-        for file_data in message["files"]:
-            # Gradio file objects have a .path attribute
-            files_content += parse_file(file_data)
+    # Process Files
+    context_from_files = ""
+    for f in files:
+        # f can be a filepath string or a dict depending on upload status
+        path = f["path"] if isinstance(f, dict) else f
+        context_from_files += parse_file(path)
     
-    # 2. Logic for "Web Search" trigger
-    # A simple keyword trigger or the LLM can decide. For now, we look for 'search' or 'docs'.
-    if "search" in user_text.lower() or "documentation" in user_text.lower():
-        search_query = user_text.replace("search", "").strip()
-        web_results = web_search(search_query)
-        full_user_input = f"RESEARCH RESULTS:\n{web_results}\n\nUSER FILES:\n{files_content}\n\nUSER QUESTION: {user_text}"
+    # Research Trigger
+    if any(keyword in user_text.lower() for keyword in ["search", "docs", "latest"]):
+        research_context = web_search(user_text)
+        prompt = f"RESEARCH:\n{research_context}\n\nFILES:\n{context_from_files}\n\nUSER: {user_text}"
     else:
-        full_user_input = f"USER FILES:\n{files_content}\n\nUSER QUESTION: {user_text}"
+        prompt = f"FILES:\n{context_from_files}\n\nUSER: {user_text}"
 
-    # 3. Construct Messages for Inference
+    # Build Gradio 6.0 compliant messages
     messages = [{"role": "system", "content": SYSTEM_PROMPT}]
-    for turn in history:
-        messages.append({"role": "user", "content": turn[0]})
-        messages.append({"role": "assistant", "content": turn[1]})
-    
-    messages.append({"role": "user", "content": full_user_input})
+    # 'history' is already a list of dicts in Gradio 6
+    messages.extend(history)
+    messages.append({"role": "user", "content": prompt})
 
-    # 4. Stream Response
-    response = ""
-    for message_chunk in client.chat_completion(
-        messages,
-        max_tokens=2048,
-        stream=True,
-        temperature=0.2, # Low temperature for high technical precision
-    ):
-        token = message_chunk.choices[0].delta.content
+    response_text = ""
+    for chunk in client.chat_completion(messages, max_tokens=2048, stream=True, temperature=0.2):
+        token = chunk.choices[0].delta.content
         if token:
-            response += token
-            yield response
+            response_text += token
+            yield response_text

requirements.txt

@@ -1,4 +1,4 @@
-gradio
+gradio>=6.0.0
 huggingface_hub
 python-dotenv
 duckduckgo-search

storage.py

@@ -7,29 +7,83 @@ Persistence Layer - Handles the "Save/Load" functionality using Hugging Face Dat
 
 import json
 import os
+from datetime import datetime
 from huggingface_hub import HfApi, hf_hub_download
 
-REPO_ID = "prashantmatlani/chathistorycoderg" 
+# --- CONFIGURATION ---
+REPO_ID = "prashantmatlani/chathistorycoderg"
+HISTORY_DIR = "./chathistory"
+
+# Initialize the API with your token
 api = HfApi(token=os.getenv("HF_TOKEN"))
 
 def save_chat(chat_id, history):
-    """Save chat history as a JSON file to HF Dataset."""
-    file_path = f"{chat_id}.json"
-    with open(file_path, "w") as f:
-        json.dump(history, f)
+    """Saves chat to local subdirectory and syncs to Hugging Face Dataset."""
+    if not os.path.exists(HISTORY_DIR):
+        os.makedirs(HISTORY_DIR)
+    
+    # Generate a unique ID if none exists (e.g., for a brand new chat)
+    if not chat_id:
+        chat_id = datetime.now().strftime("%Y%m%d_%H%M%S")
+    
+    filename = f"{chat_id}.json"
+    local_path = os.path.join(HISTORY_DIR, filename)
     
-    api.upload_file(
-        path_or_fileobj=file_path,
-        path_in_repo=f"chats/{file_path}",
-        repo_id=REPO_ID,
-        repo_type="dataset"
-    )
+    # 1. Save Locally
+    with open(local_path, "w", encoding="utf-8") as f:
+        json.dump(history, f, indent=4)
+    
+    # 2. Sync to Hugging Face Dataset (Master Stroke Persistence)
+    try:
+        api.upload_file(
+            path_or_fileobj=local_path,
+            path_in_repo=f"chats/{filename}",
+            repo_id=REPO_ID,
+            repo_type="dataset"
+        )
+    except Exception as e:
+        print(f"Cloud Sync Warning: {e}")
+        
+    return chat_id
 
 def load_history():
-    """Retrieve all past chat IDs for the sidebar."""
+    """Retrieves list of chat IDs from the Hub to populate the sidebar."""
     try:
+        # We pull the list from the Hub so the sidebar reflects all saved sessions
         files = api.list_repo_files(repo_id=REPO_ID, repo_type="dataset")
-        chat_files = [f.split("/")[-1].replace(".json", "") for f in files if f.startswith("chats/")]
-        return [[f] for f in chat_files]
-    except Exception:
+        chat_files = [
+            f.split("/")[-1].replace(".json", "") 
+            for f in files if f.startswith("chats/")
+        ]
+        # Return as list of lists for Gradio Dataset component
+        return [[f] for f in sorted(chat_files, reverse=True)]
+    except Exception as e:
+        print(f"Error loading history from Hub: {e}")
         return []
+
+def get_chat_content(chat_id):
+    """Loads a specific chat's content from the Hub or local cache."""
+    filename = f"chats/{chat_id}.json"
+    local_path = os.path.join(HISTORY_DIR, f"{chat_id}.json")
+    
+    try:
+        # Ensure local dir exists
+        if not os.path.exists(HISTORY_DIR):
+            os.makedirs(HISTORY_DIR)
+            
+        # Download from Hub to keep local state fresh
+        from huggingface_hub import hf_hub_download
+        downloaded_path = hf_hub_download(
+            repo_id=REPO_ID, 
+            repo_type="dataset", 
+            filename=filename,
+            token=os.getenv("HF_TOKEN")
+        )
+        with open(downloaded_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        # Fallback to local if Hub is unreachable
+        if os.path.exists(local_path):
+            with open(local_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+    return []