Implement per-user agent builder isolation - Each user now sees only their own agents

app.py

@@ -36,6 +36,8 @@ from session_helpers import (
     get_user_simple_chat_history, set_user_simple_chat_history,
     get_user_builder_chat_histories, set_user_builder_chat_histories,
     get_user_deployed_chat_histories, set_user_deployed_chat_histories,
+    get_user_agents_config, set_user_agents_config,
+    save_user_agent, get_user_agent, remove_user_agent, get_user_agent_names,
     get_current_username, log_user_access
 )
 from core.agents.agent_utils import linkify_citations, build_agent, load_prefilled, prepare_download, preload_demo_chat, _safe_title, extract_clinical_variables_from_history
@@ -147,9 +149,12 @@ def reset_chat(agent_json):
     active_children= []
     return chat_history, "", invocation_log, active_children
 
-def load_agent_to_builder(agent_name):
-    if agent_name in agents_config:
-        agent_data = json.loads(agents_config[agent_name])
+def load_agent_to_builder(agent_name, request: gr.Request):
+    """Load agent to builder - per-user isolation."""
+    agent_json = get_user_agent(request, agent_name)
+    if agent_json:
+        agent_data = json.loads(agent_json)
+        log_user_access(request, f"load_agent_to_builder: {agent_name}")
         return (
             agent_data.get("agent_type", ""),
             agent_data.get("agent_name", ""),
@@ -159,19 +164,21 @@ def load_agent_to_builder(agent_name):
     else:
         return None, "", "", []
 
-def remove_selected_agent(agent_name: str):
-    # 1) Remove from your in-memory store
-    if agent_name in agents_config:
-        del agents_config[agent_name]
+def remove_selected_agent(agent_name: str, request: gr.Request):
+    """Remove agent from user's configuration - per-user isolation."""
+    # Remove from user's session
+    removed = remove_user_agent(request, agent_name)
+    log_user_access(request, f"remove_agent: {agent_name}")
 
-    # 2) Re-render the list of active agents
-    if agents_config:
-        active_md = "### 🧠 Active Agents\n" + "\n".join(f"- {name}" for name in agents_config)
+    # 2) Re-render the list of active agents for THIS USER
+    user_agent_names = get_user_agent_names(request)
+    if user_agent_names:
+        active_md = "### 🧠 Active Agents\n" + "\n".join(f"- {name}" for name in user_agent_names)
     else:
         active_md = "### 🧠 Active Agents\n_(None yet)_"
 
-    # 3) Build the new dropdown state
-    new_choices = list(agents_config.keys())
+    # 3) Build the new dropdown state for THIS USER
+    new_choices = user_agent_names
     # gr.update to reset selection (value=None) and update choices
     dropdown_update = gr.update(choices=new_choices, value=None)
 
@@ -211,8 +218,10 @@ def on_agent_type_change(selected_type, was_prefilled):
     # manual change: clear everything
     return skill_update, gr.update(value=""), gr.update(value=""), False
 
-def chat_selected_agent(agent_name):
-    agent_json = agents_config.get(agent_name, "")
+def chat_selected_agent(agent_name, request: gr.Request):
+    """Load agent for chat - per-user isolation."""
+    agent_json = get_user_agent(request, agent_name)
+    log_user_access(request, f"chat_selected_agent: {agent_name}")
     if agent_json:
         # reset_chat returns 4 values:
         # (chat_history, cleared_input, invocation_log, active_children)
@@ -298,8 +307,8 @@ def chatpanel_handle(agent_name, user_text, request: gr.Request):
     histories = get_user_deployed_chat_histories(request)
     log_user_access(request, f"chatpanel_handle for agent {agent_name}")
     
-    # 1) Look up the JSON you saved in agents_config
-    agent_json = agents_config.get(agent_name)
+    # 1) Look up the JSON from USER's agents, not global
+    agent_json = get_user_agent(request, agent_name)
     if not agent_json:
         return [], histories, "", ""
 
@@ -344,8 +353,10 @@ def chatpanel_handle(agent_name, user_text, request: gr.Request):
     
     return final_history, histories, "", final_invocation_log
 
-def refresh_chat_dropdown():
-    return gr.update(choices=list(agents_config.keys()), value=None)
+def refresh_chat_dropdown(request: gr.Request):
+    """Refresh chat dropdown with user's agents only."""
+    user_agent_names = get_user_agent_names(request)
+    return gr.update(choices=user_agent_names, value=None)
 
 def build_ui():
     # --- App Layout ---
@@ -2114,14 +2125,17 @@ def build_ui():
             outputs=[agent_type, agent_name, agent_mission, skills, prefill_flag]
         )
         uploaded_files.upload(fn=handle_uploaded_files, inputs=[uploaded_files], outputs=[upload_alert, upload_alert])
-        def handle_generate(agent_type, agent_name, agent_mission, selected_skills, web_access, allow_fallback, uploaded_files, link1, link2, link3, link4, challenger_toggle):
+        def handle_generate(agent_type, agent_name, agent_mission, selected_skills, web_access, allow_fallback, uploaded_files, link1, link2, link3, link4, challenger_toggle, request: gr.Request):
             # Accept challenger_toggle as an argument
+            # PER-USER AGENT STORAGE
             agent_json = build_agent(agent_type, agent_name, agent_mission, selected_skills, web_access, allow_fallback, uploaded_files, link1, link2, link3, link4)
             # Add challenger_enabled to the agent config JSON
             agent_data = json.loads(agent_json)
             agent_data["challenger_enabled"] = challenger_toggle
             agent_json = json.dumps(agent_data)
-            agents_config[agent_name] = agent_json
+            # Save to USER's session, not global
+            save_user_agent(request, agent_name, agent_json)
+            log_user_access(request, f"generated_agent: {agent_name}")
             return agent_json
 
         generate_button.click(

core/ui/ui.py

@@ -5,6 +5,9 @@ from core.agents.chat_orchestrator import simulate_agent_response_stream
 import logging
 from config import agents_config, skills_library, prefilled_agents
 
+# Import session helpers for per-user agent storage
+from session_helpers import get_user_agents_config
+
 def show_landing():
     return gr.update(visible=True),  gr.update(visible=False), gr.update(visible=False)
 
@@ -14,19 +17,24 @@ def show_builder():
 def show_chat():
     return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)
 
-def build_active_agents_markdown_and_dropdown():
-    if not agents_config:
+def build_active_agents_markdown_and_dropdown(request: gr.Request):
+    """Build active agents list - per-user isolation."""
+    # Get user's agents, not global
+    user_agents_config = get_user_agents_config(request)
+    
+    if not user_agents_config:
         return "### 🧠 Active Agents\n_(None yet)_", []
     output = "### 🧠 Active Agents\n"
     dropdown_choices = []
-    for name, agent_json in agents_config.items():
+    for name, agent_json in user_agents_config.items():
         agent_type = json.loads(agent_json)["agent_type"]
         output += f"- {name} ({agent_type})\n"
         dropdown_choices.append(name)
     return output, dropdown_choices
 
-def refresh_active_agents_widgets():
-    md, dd = build_active_agents_markdown_and_dropdown()
+def refresh_active_agents_widgets(request: gr.Request):
+    """Refresh active agents widgets - per-user isolation."""
+    md, dd = build_active_agents_markdown_and_dropdown(request)
     return gr.update(value=md), gr.update(choices=dd, value=None)
 
 # All other UI callback functions from app.py

session_helpers.py

@@ -168,6 +168,51 @@ def wrap_load_history(original_func):
     return wrapper
 
 
+def get_user_agents_config(request: gr.Request) -> Dict:
+    """Get agents configuration for current user."""
+    username = get_username_from_request(request)
+    return session_manager.get_user_data(username, SessionKeys.AGENTS_CONFIG, default={})
+
+
+def set_user_agents_config(request: gr.Request, config: Dict) -> None:
+    """Set agents configuration for current user."""
+    username = get_username_from_request(request)
+    session_manager.set_user_data(username, SessionKeys.AGENTS_CONFIG, config)
+
+
+def save_user_agent(request: gr.Request, agent_name: str, agent_json: str) -> None:
+    """Save an agent to the current user's configuration."""
+    username = get_username_from_request(request)
+    agents_config = get_user_agents_config(request)
+    agents_config[agent_name] = agent_json
+    set_user_agents_config(request, agents_config)
+    logger.info(f"User '{username}' saved agent: {agent_name}")
+
+
+def get_user_agent(request: gr.Request, agent_name: str) -> str:
+    """Get a specific agent from the current user's configuration."""
+    agents_config = get_user_agents_config(request)
+    return agents_config.get(agent_name, "")
+
+
+def remove_user_agent(request: gr.Request, agent_name: str) -> bool:
+    """Remove an agent from the current user's configuration."""
+    username = get_username_from_request(request)
+    agents_config = get_user_agents_config(request)
+    if agent_name in agents_config:
+        del agents_config[agent_name]
+        set_user_agents_config(request, agents_config)
+        logger.info(f"User '{username}' removed agent: {agent_name}")
+        return True
+    return False
+
+
+def get_user_agent_names(request: gr.Request) -> List[str]:
+    """Get list of agent names for the current user."""
+    agents_config = get_user_agents_config(request)
+    return list(agents_config.keys())
+
+
 def log_user_access(request: gr.Request, action: str):
     """Log user access for debugging/auditing."""
     username = get_username_from_request(request)

user_session_manager.py

@@ -182,6 +182,7 @@ class SessionKeys:
     PATIENT_DATA = "patient_data"
     AGENT_OUTPUT = "agent_output"
     PREFILL_FLAG = "prefill_flag"
+    AGENTS_CONFIG = "agents_config"  # Per-user agent storage
 
 
 if __name__ == "__main__":