Upload autonomous lab application

SPOC_V1/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

SPOC_V1/README.md

@@ -0,0 +1,12 @@
+---
+title: SPOC V1
+emoji: 📉
+colorFrom: green
+colorTo: indigo
+sdk: gradio
+sdk_version: 5.47.2
+app_file: app.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,98 @@
+# app.py (Updated with Triage Orchestration)
+
+import os
+import math
+from flask import Flask, render_template, request, jsonify
+from dotenv import load_dotenv
+from graph import triage_app, planner_app, main_app # Import all three compiled apps
+from utils import generate_mermaid_diagram
+
+load_dotenv()
+app = Flask(__name__)
+
+# Create necessary directories on startup
+os.makedirs("outputs", exist_ok=True)
+os.makedirs("uploads", exist_ok=True)
+os.makedirs("memory", exist_ok=True)
+os.makedirs("logs", exist_ok=True)
+
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+
+@app.route('/estimate', methods=['POST'])
+def estimate():
+    data = request.json
+    user_input = data.get('message', '').strip()
+    if not user_input:
+        return jsonify({"error": "Message cannot be empty."}), 400
+    
+    # --- NEW TRIAGE STEP ---
+    # First, check if the input is a simple greeting
+    triage_inputs = {"userInput": user_input}
+    triage_result = triage_app.invoke(triage_inputs)
+    
+    # If the triage agent provided a direct response, it's a greeting.
+    if triage_result.get("draftResponse"):
+        # We add a special key to let the frontend know to just display the message
+        return jsonify({"is_greeting": True, "response": triage_result["draftResponse"]})
+
+    # --- If not a greeting, proceed to the planner ---
+    planner_inputs = {"userInput": user_input}
+    try:
+        estimate_result = planner_app.invoke(planner_inputs)
+        estimate_result['pmPlan']['is_greeting'] = False
+        return jsonify(estimate_result.get('pmPlan', {}))
+    except Exception as e:
+        return jsonify({"error": "An unexpected error occurred during planning."}), 500
+
+
+@app.route('/chat', methods=['POST'])
+def chat():
+    data = request.json
+    user_input = data.get('message', '').strip()
+    
+    try:
+        user_budget = float(data.get('user_budget', 0.0))
+        cost_per_loop = float(data.get('cost_per_loop', 0.05))
+    except (ValueError, TypeError):
+        return jsonify({"error": "Invalid budget or cost format."}), 400
+
+    if not user_input:
+        return jsonify({"error": "Message cannot be empty."}), 400
+
+    if cost_per_loop > 0:
+        total_runs_affordable = max(1, math.floor(user_budget / cost_per_loop))
+        max_loops_calibrated = total_runs_affordable - 1
+    else:
+        max_loops_calibrated = 0
+
+    initial_state = {
+        "userInput": user_input, "chatHistory": [], "coreObjectivePrompt": "",
+        "retrievedMemory": "", "pmPlan": {}, "experimentCode": None,
+        "experimentResults": None, "draftResponse": "", "qaFeedback": None,
+        "approved": False, "execution_path": [], "rework_cycles": 0,
+        "max_loops": max_loops_calibrated
+    }
+    
+    try:
+        final_state = main_app.invoke(initial_state)
+    except Exception as e:
+        return jsonify({"response": "An unexpected error occurred during execution. Please check the logs."}), 500
+    
+    run_path = final_state.get('execution_path', [])
+    if run_path:
+        mermaid_syntax = generate_mermaid_diagram(run_path)
+        with open("outputs/last_run_flow.md", "w") as f:
+            f.write("# Last Run Execution Flow\n\n")
+            f.write("```mermaid\n")
+            f.write(mermaid_syntax)
+            f.write("```\n")
+            
+    response = final_state.get('draftResponse', "An error occurred, and no response was generated.")
+    return jsonify({"response": response})
+
+if __name__ == '__main__':
+    app.run(debug=True, port=5001)

app_gradio.py

@@ -0,0 +1,227 @@
+# app_gradio.py (Feature-Complete with Authentication)
+
+import gradio as gr
+import math
+import os
+import json
+from datetime import datetime
+from dotenv import load_dotenv
+
+# Import your existing agentic logic
+from graph import triage_app, planner_app, main_app
+from logging_config import get_logger
+
+# --- Setup & Configuration ---
+load_dotenv()
+log = get_logger(__name__)
+
+# Create necessary directories on startup
+os.makedirs("outputs", exist_ok=True)
+os.makedirs("uploads", exist_ok=True)
+os.makedirs("conversations", exist_ok=True)
+
+# --- FEATURE: Basic & Secure Authentication ---
+# A simple dictionary of allowed users.
+# In a real product, this would come from a secure database.
+USERS = {
+    "tester1": "pass123",
+    "researcher": "lab456",
+    "admin": "admin789"
+}
+
+# --- State Management ---
+def get_default_state():
+    """Initializes a new session state."""
+    return {
+        "original_user_message": "",
+        "estimate": {},
+        "current_conversation_file": None,
+    }
+
+# --- Backend I/O Functions ---
+
+# --- FEATURE: Conversation Management ---
+def save_conversation(history, state):
+    """Saves the current chat history to a timestamped JSON file."""
+    if not history:
+        return "Nothing to save."
+    
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"conv_{timestamp}.json"
+    filepath = os.path.join("conversations", filename)
+    
+    with open(filepath, 'w', encoding='utf-8') as f:
+        json.dump(history, f, indent=2)
+        
+    state["current_conversation_file"] = filepath
+    log.info(f"Conversation saved to {filepath}")
+    # Return a confirmation message to a Gradio component
+    return f"Saved to {filename}", gr.update(choices=get_saved_conversations())
+
+def load_conversation(filepath, state):
+    """Loads a chat history from a JSON file."""
+    if not filepath:
+        return [], state
+    
+    with open(filepath, 'r', encoding='utf-8') as f:
+        history = json.load(f)
+        
+    state["current_conversation_file"] = filepath
+    log.info(f"Conversation loaded from {filepath}")
+    return history, state
+
+def get_saved_conversations():
+    """Returns a list of saved conversation file paths."""
+    return [os.path.join("conversations", f) for f in os.listdir("conversations") if f.endswith(".json")]
+
+def clear_conversation():
+    """Resets the chat to a new, empty state."""
+    return [], get_default_state()
+
+# --- FEATURE: Artifact Management ---
+def handle_file_upload(file, state):
+    """Saves an uploaded file to the /uploads directory."""
+    if file is None:
+        return "No file uploaded."
+    
+    # Gradio provides the file object with a `name` attribute (the original path)
+    basename = os.path.basename(file.name)
+    destination_path = os.path.join("uploads", basename)
+    
+    # The file object is already on disk in a temporary location, so we move it
+    os.rename(file.name, destination_path)
+    
+    log.info(f"File uploaded to {destination_path}")
+    return f"Uploaded: {basename}"
+
+def update_artifact_list():
+    """Scans the outputs directory and returns a list of files as Markdown links."""
+    output_files = os.listdir("outputs")
+    if not output_files:
+        return "No artifacts generated yet."
+    
+    # Gradio can't serve files directly, so we use this workaround for local execution
+    # For a real web deployment, these would be proper download links.
+    markdown_list = "### Generated Artifacts:\n"
+    for f in output_files:
+        markdown_list += f"- `{f}` (in your 'outputs' folder)\n"
+        
+    return markdown_list
+
+# --- Core Logic Functions (Unchanged) ---
+def start_estimation(message, history, state):
+    log.info(f"Starting estimation for: '{message}'")
+    state["original_user_message"] = message
+    history.append({"role": "user", "content": message})
+    yield history, state, gr.update(value="", interactive=False), gr.update(visible=False), gr.update()
+
+    triage_inputs = {"userInput": message}
+    triage_result = triage_app.invoke(triage_inputs)
+
+    if triage_result.get("draftResponse"):
+        history.append({"role": "assistant", "content": triage_result["draftResponse"]})
+        yield history, state, gr.update(interactive=True), gr.update(visible=False), gr.update()
+        return
+
+    planner_inputs = {"userInput": message}
+    estimate_result = planner_app.invoke(planner_inputs)
+    estimate = estimate_result.get('pmPlan', {})
+    state["estimate"] = estimate
+
+    if estimate.get("error"):
+        history.append({"role": "assistant", "content": f"Error during planning: {estimate['error']}"})
+        yield history, state, gr.update(interactive=True), gr.update(visible=False), gr.update()
+    else:
+        plan_text = "\n".join([f"- {step}" for step in estimate.get('plan', [])])
+        approval_text_md = (f"**Here is my plan:**\n{plan_text}\n\nThis may require up to **{estimate.get('max_loops_initial', 0) + 1} attempts** and could cost approximately **${estimate.get('estimated_cost_usd', 0.0)}**.")
+        yield history, state, gr.update(interactive=False), gr.update(visible=True, value=approval_text_md), gr.update(value=estimate.get('estimated_cost_usd', 0.10))
+
+def execute_main_task(history, state, budget):
+    log.info(f"Executing main task with budget: ${budget}")
+    yield history, state, gr.update(visible=False), gr.update(value="", interactive=False)
+
+    history.append({"role": "assistant", "content": "Executing task within budget..."})
+    yield history, state, gr.update(visible=False), gr.update(interactive=False)
+
+    cost_per_loop = state["estimate"].get('cost_per_loop_usd', 0.05)
+    if cost_per_loop > 0:
+        total_runs_affordable = max(1, math.floor(float(budget) / cost_per_loop))
+        max_loops_calibrated = total_runs_affordable - 1
+    else:
+        max_loops_calibrated = 0
+
+    initial_state = { "userInput": state["original_user_message"], "chatHistory": [], "coreObjectivePrompt": "", "retrievedMemory": "", "pmPlan": {}, "experimentCode": None, "experimentResults": None, "draftResponse": "", "qaFeedback": None, "approved": False, "execution_path": [], "rework_cycles": 0, "max_loops": max_loops_calibrated }
+    
+    final_state = main_app.invoke(initial_state)
+    final_response = final_state.get('draftResponse', "An error occurred.")
+    
+    history[-1] = {"role": "assistant", "content": final_response}
+    
+    yield history, state, gr.update(visible=False), gr.update(interactive=True)
+
+def cancel_task(history, state):
+    history.append({"role": "assistant", "content": "Task cancelled."})
+    return history, state, gr.update(visible=False), gr.update(interactive=True)
+
+# --- Gradio UI Definition ---
+with gr.Blocks(theme=gr.themes.Soft(), title="Autonomous AI Lab") as demo:
+    state = gr.State(value=get_default_state())
+
+    gr.Markdown("# Autonomous AI Lab")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            # --- FEATURE: Sidebar controls ---
+            gr.Markdown("### Controls")
+            clear_btn = gr.Button("🗑️ New Conversation")
+            
+            gr.Markdown("### Saved Chats")
+            saved_chats_dropdown = gr.Dropdown(label="Load a past conversation", choices=get_saved_conversations(), interactive=True)
+            save_chat_btn = gr.Button("💾 Save Current Chat")
+            save_status_text = gr.Textbox(label="Save Status", interactive=False)
+            
+            gr.Markdown("### Artifacts")
+            file_uploader = gr.File(label="Upload a file")
+            upload_status_text = gr.Textbox(label="Upload Status", interactive=False)
+            
+            refresh_artifacts_btn = gr.Button("🔄 Refresh Artifacts List")
+            artifact_list_display = gr.Markdown("No artifacts generated yet.")
+
+        with gr.Column(scale=4):
+            chatbot = gr.Chatbot(label="Conversation", height=600, type="messages", avatar_images=(None, "https://i.imgur.com/b5OqI32.png"))
+            
+            # --- FEATURE: Approval box is now part of the main layout ---
+            with gr.Group(visible=False) as approval_box:
+                approval_text = gr.Markdown()
+                with gr.Row():
+                    budget_input = gr.Number(label="Set your maximum budget ($)", value=0.10, minimum=0.01, step=0.05)
+                with gr.Row():
+                    proceed_btn = gr.Button("✅ Approve & Proceed", variant="primary")
+                    cancel_btn = gr.Button("❌ Cancel")
+
+            with gr.Row():
+                msg_textbox = gr.Textbox(label="Your Message", placeholder="Ask a question or describe a task...", scale=7)
+                submit_btn = gr.Button("Send", variant="primary", scale=1)
+
+    # --- Event Handlers ---
+    # Main chat flow
+    msg_textbox.submit(fn=start_estimation, inputs=[msg_textbox, chatbot, state], outputs=[chatbot, state, msg_textbox, approval_box, budget_input])
+    submit_btn.click(fn=start_estimation, inputs=[msg_textbox, chatbot, state], outputs=[chatbot, state, msg_textbox, approval_box, budget_input])
+    proceed_btn.click(fn=execute_main_task, inputs=[chatbot, state, budget_input], outputs=[chatbot, state, approval_box, msg_textbox])
+    cancel_btn.click(fn=cancel_task, inputs=[chatbot, state], outputs=[chatbot, state, approval_box, msg_textbox])
+    
+    # Sidebar controls
+    clear_btn.click(fn=clear_conversation, inputs=[], outputs=[chatbot, state])
+    save_chat_btn.click(fn=save_conversation, inputs=[chatbot, state], outputs=[save_status_text, saved_chats_dropdown])
+    saved_chats_dropdown.change(fn=load_conversation, inputs=[saved_chats_dropdown, state], outputs=[chatbot, state])
+    file_uploader.upload(fn=handle_file_upload, inputs=[file_uploader, state], outputs=[upload_status_text])
+    refresh_artifacts_btn.click(fn=update_artifact_list, inputs=[], outputs=[artifact_list_display])
+
+if __name__ == "__main__":
+    # --- FEATURE: Add authentication to the launch() method ---
+    demo.launch(
+        share=True,
+        debug=True,
+        auth=[(user, pwd) for user, pwd in USERS.items()],
+        auth_message="Enter your credentials to access the Autonomous AI Lab."
+    )

code_executor.py

@@ -0,0 +1,44 @@
+import subprocess
+import sys
+import os
+import tempfile
+import shutil
+
+def execute_python_code(code: str, timeout: int = 30) -> dict:
+    """
+    Executes Python code in a temporary directory and returns the output.
+    """
+    temp_dir = tempfile.mkdtemp()
+    script_path = os.path.join(temp_dir, "script.py")
+
+    with open(script_path, "w") as f:
+        f.write(code)
+    
+    python_executable = sys.executable
+    
+    try:
+        print(f"🧪 Executing code in a temporary environment...")
+        process = subprocess.run(
+            [python_executable, script_path],
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            cwd=temp_dir
+        )
+        
+        stdout = process.stdout
+        stderr = process.stderr
+        success = process.returncode == 0
+        
+    except subprocess.TimeoutExpired:
+        stdout = ""
+        stderr = f"Execution timed out after {timeout} seconds."
+        success = False
+    except Exception as e:
+        stdout = ""
+        stderr = f"An unexpected error occurred: {str(e)}"
+        success = False
+    finally:
+        shutil.rmtree(temp_dir)
+        
+    return {"stdout": stdout, "stderr": stderr, "success": success}

graph.py

@@ -0,0 +1,275 @@
+# graph.py (Updated with Triage Agent)
+
+import json
+import re
+import math
+from typing import TypedDict, List, Dict, Optional
+from langchain_openai import ChatOpenAI
+from langgraph.graph import StateGraph, END, START
+from memory_manager import memory_manager
+from code_executor import execute_python_code
+from logging_config import setup_logging, get_logger
+
+# --- Setup Logging & Constants ---
+setup_logging()
+log = get_logger(__name__)
+INITIAL_MAX_REWORK_CYCLES = 3 
+GPT4O_INPUT_COST_PER_1K_TOKENS = 0.005
+GPT4O_OUTPUT_COST_PER_1K_TOKENS = 0.015
+AVG_TOKENS_PER_CALL = 2.0 
+
+# --- Agent State Definition ---
+class AgentState(TypedDict):
+    userInput: str
+    chatHistory: List[str]
+    coreObjectivePrompt: str
+    retrievedMemory: Optional[str]
+    pmPlan: Dict
+    experimentCode: Optional[str]
+    experimentResults: Optional[Dict]
+    draftResponse: str
+    qaFeedback: Optional[str]
+    approved: bool
+    execution_path: List[str]
+    rework_cycles: int
+    max_loops: int
+
+# --- Helper for Robust JSON Parsing ---
+def parse_json_from_llm(llm_output: str) -> Optional[dict]:
+    try:
+        match = re.search(r"```json\n({.*?})\n```", llm_output, re.DOTALL)
+        if match:
+            json_str = match.group(1)
+        else:
+            json_str = llm_output[llm_output.find('{'):llm_output.rfind('}')+1]
+        
+        return json.loads(json_str)
+    except (json.JSONDecodeError, AttributeError) as e:
+        log.error(f"JSON parsing failed. Raw output: '{llm_output}'. Error: {e}")
+        return None
+
+# --- LLM Initialization ---
+llm = ChatOpenAI(model="gpt-4o", temperature=0.1, max_retries=3, request_timeout=60)
+
+# --- NEW: Triage Agent ---
+def run_triage_agent(state: AgentState):
+    log.info("---  triage ---")
+    prompt = f"Analyze the user input. Is it a simple conversational greeting (e.g., 'hello', 'hi', 'how are you?') that doesn't require a complex plan, or is it a task/question that needs to be decomposed and executed? Respond with 'greeting' or 'task'.\n\nUser Input: \"{state['userInput']}\""
+    response = llm.invoke(prompt)
+    
+    if 'greeting' in response.content.lower():
+        log.info("Triage result: Simple Greeting. Bypassing main workflow.")
+        # Set a direct, simple response
+        return {
+            "draftResponse": "Hello! How can I help you today?",
+            "execution_path": ["Triage Agent"]
+        }
+    else:
+        log.info("Triage result: Complex Task. Proceeding to planner.")
+        # Let the main workflow handle it
+        return { "execution_path": ["Triage Agent"] }
+
+def should_start_full_workflow(state: AgentState):
+    """Conditional edge to decide if we run the full graph or end early."""
+    if state.get("draftResponse"):
+        # If the triage agent already set a response, we are done.
+        return "end_early"
+    else:
+        return "planner"
+
+# --- Agent Node Functions (Planner, PM, etc. are unchanged) ---
+def run_planner_agent(state: AgentState):
+    log.info("--- ✈️ Running Planner Agent for Pre-flight Check ---")
+    path = state.get('execution_path', []) + ["Planner Agent"]
+    prompt = f"Analyze the user's request and provide a high-level plan and cost estimate. 1. Decompose the request into high-level steps. 2. Count the likely number of specialist LLM calls needed for ONE successful loop. User Request: \"{state['userInput']}\". Provide the output ONLY as a valid JSON object within ```json code fences with keys: 'plan' (list of strings), 'estimated_llm_calls_per_loop' (integer)."
+    
+    response = llm.invoke(prompt)
+    plan_data = parse_json_from_llm(response.content)
+
+    if not plan_data:
+        return {"pmPlan": {"error": "Failed to create a valid plan."}, "execution_path": path}
+
+    calls_per_loop = plan_data.get('estimated_llm_calls_per_loop', 3)
+    cost_per_loop = (calls_per_loop * AVG_TOKENS_PER_CALL) * ( (GPT4O_INPUT_COST_PER_1K_TOKENS + GPT4O_OUTPUT_COST_PER_1K_TOKENS) / 2 )
+    estimated_cost = cost_per_loop * (INITIAL_MAX_REWORK_CYCLES + 1)
+    
+    plan_data['max_loops_initial'] = INITIAL_MAX_REWORK_CYCLES
+    plan_data['estimated_cost_usd'] = round(estimated_cost, 2)
+    plan_data['cost_per_loop_usd'] = max(0.01, round(cost_per_loop, 3))
+    
+    log.info(f"Pre-flight Estimate: {plan_data}")
+    return {"pmPlan": plan_data, "execution_path": path}
+
+# --- All other agent functions remain the same ---
+# ... (run_pm_agent, run_memory_retrieval, etc.)
+def run_memory_retrieval(state: AgentState):
+    log.info("--- 🧠 Accessing Long-Term Memory ---")
+    path = state.get('execution_path', []) + ["Memory Retriever"]
+    relevant_mems = memory_manager.retrieve_relevant_memories(state['userInput'])
+    if relevant_mems:
+        context = "\n".join([f"Memory: {mem.page_content}" for mem in relevant_mems])
+        log.info(f"Found {len(relevant_mems)} relevant memories.")
+    else:
+        context = "No relevant memories found."
+        log.info(context)
+    return {"retrievedMemory": context, "execution_path": path}
+
+def run_intent_agent(state: AgentState):
+    log.info("--- 🎯 Running Intent Agent ---")
+    path = state.get('execution_path', []) + ["Intent Agent"]
+    prompt = f"As an expert prompt engineer, analyze the user's request, conversation history, and retrieved memories. Refine it into a clear, actionable 'core objective prompt'.\n\nRelevant Memory:\n{state.get('retrievedMemory')}\n\nUser Request: \"{state.get('userInput')}\"\n\nCore Objective:"
+    response = llm.invoke(prompt)
+    return {"coreObjectivePrompt": response.content, "execution_path": path}
+
+def run_pm_agent(state: AgentState):
+    log.info("--- 👷 Running PM Agent ---")
+    current_cycles = state.get('rework_cycles', 0) + 1
+    log.info(f"Starting work cycle {current_cycles}/{state.get('max_loops', 0) + 1}")
+
+    path = state.get('execution_path', []) + ["PM Agent"]
+    feedback = f"QA Feedback (must be addressed): {state.get('qaFeedback')}" if state.get('qaFeedback') else ""
+    prompt = f"As the Project Manager, decompose the core objective into a plan. Identify if code execution is needed. If so, define the goal of the experiment.\n\nCore Objective: {state.get('coreObjectivePrompt')}\n\n{feedback}\n\nProvide your plan ONLY as a valid JSON object within ```json code fences with keys: 'plan_steps' (list of strings) and 'experiment_needed' (boolean). If 'experiment_needed' is true, also include 'experiment_goal' (string)."
+    
+    response = llm.invoke(prompt)
+    plan = parse_json_from_llm(response.content)
+
+    if not plan:
+        log.error("PM Agent failed to produce a valid JSON plan.")
+        plan = {"plan_steps": ["Error: The Project Manager failed to create a valid plan."], "experiment_needed": False}
+    
+    log.info(f"Generated Plan: Experiment Needed = {plan.get('experiment_needed', False)}")
+    return {"pmPlan": plan, "execution_path": path, "rework_cycles": current_cycles}
+
+def run_experimenter_agent(state: AgentState):
+    log.info("--- 🔬 Running Experimenter Agent ---")
+    path = state.get('execution_path', []) + ["Experimenter Agent"]
+    if not state.get('pmPlan', {}).get('experiment_needed'):
+        return {"experimentCode": None, "experimentResults": None, "execution_path": path}
+    
+    goal = state.get('pmPlan', {}).get('experiment_goal', 'No goal specified.')
+    prompt = f"Write a Python script to achieve this goal. Do not require user input. Print results to standard output.\n\nGoal: {goal}\n\nPython Code:\n```python\n# Your code here\n```"
+    response = llm.invoke(prompt)
+    code_match = re.search(r"```python\n(.*?)\n```", response.content, re.DOTALL)
+    if not code_match:
+        log.error("Experimenter failed to generate valid Python code within fences.")
+        return {"experimentCode": "# ERROR: No code generated", "experimentResults": {"success": False, "stderr": "No valid Python code block was generated."}, "execution_path": path}
+    
+    code = code_match.group(1).strip()
+    results = execute_python_code(code)
+    return {"experimentCode": code, "experimentResults": results, "execution_path": path}
+
+def run_synthesis_agent(state: AgentState):
+    log.info("--- ✍️ Running Synthesis Agent ---")
+    path = state.get('execution_path', []) + ["Synthesis Agent"]
+    exp_results = state.get('experimentResults')
+    results_summary = "No experiment was conducted."
+    if exp_results:
+        results_summary = f"An experiment was conducted. Output:\nSTDOUT:\n{exp_results.get('stdout', '')}\nSTDERR:\n{exp_results.get('stderr', '')}"
+    
+    prompt = f"Synthesize all information into a final response.\n\nCore Objective: {state.get('coreObjectivePrompt')}\n\nPlan: {state.get('pmPlan', {}).get('plan_steps')}\n\n{results_summary}\n\nFinal Response:"
+    response = llm.invoke(prompt)
+    return {"draftResponse": response.content, "execution_path": path}
+
+def run_qa_agent(state: AgentState):
+    log.info("--- ✅ Running QA Agent ---")
+    path = state.get('execution_path', []) + ["QA Agent"]
+    prompt = f"Review the draft response based on the core objective. Respond ONLY with 'APPROVED' if it is complete and accurate. Otherwise, provide concise feedback for rework.\n\nCore Objective: {state.get('coreObjectivePrompt')}\n\nDraft Response: {state.get('draftResponse')}"
+    response = llm.invoke(prompt)
+    if "APPROVED" in response.content.upper():
+        return {"approved": True, "qaFeedback": None, "execution_path": path}
+    else:
+        return {"approved": False, "qaFeedback": response.content or "No specific feedback provided.", "execution_path": path}
+
+def run_archivist_agent(state: AgentState):
+    log.info("--- 💾 Running Archivist Agent ---")
+    path = state.get('execution_path', []) + ["Archivist Agent"]
+    summary_prompt = f"Create a concise summary of this successful task for long-term memory. Focus on key insights and results.\n\nCore Objective: {state.get('coreObjectivePrompt')}\n\nFinal Response: {state.get('draftResponse')}\n\nMemory Summary:"
+    
+    # FIX: Use the correct variable name 'summary_prompt' instead of 'prompt'
+    response = llm.invoke(summary_prompt)
+    
+    memory_manager.add_to_memory(response.content, {"objective": state.get('coreObjectivePrompt')})
+    return {"execution_path": path}
+
+def run_disclaimer_agent(state: AgentState):
+    log.warning("--- ⚠️ Running Disclaimer Agent ---")
+    path = state.get('execution_path', []) + ["Disclaimer Agent"]
+    disclaimer = "**DISCLAIMER: The process was stopped after exhausting the user-defined budget. The following response is the best available draft but may be incomplete, unverified, or contain errors. Please review it carefully.**\n\n---\n\n"
+    final_response = disclaimer + state.get('draftResponse', "No response was generated before the budget was exhausted.")
+    return {"draftResponse": final_response, "execution_path": path}
+
+
+# --- Conditional Edges & Graph Definition ---
+# ... (should_continue and should_run_experiment are unchanged)
+def should_continue(state: AgentState):
+    log.info("--- 🤔 Decision: Is the response QA approved? ---")
+    if state.get("approved"):
+        log.info("Routing to: Archivist (Success Path)")
+        return "archivist_agent"
+    
+    if state.get("rework_cycles", 0) > state.get("max_loops", 0):
+        log.error(f"BUDGET LIMIT REACHED. Aborting task after {state.get('rework_cycles', 0)-1} rework cycles.")
+        return "disclaimer_agent"
+    else:
+        log.info("Routing to: PM Agent for rework")
+        return "pm_agent"
+
+def should_run_experiment(state: AgentState):
+    decision = "experimenter_agent" if state.get('pmPlan', {}).get('experiment_needed') else "synthesis_agent"
+    return decision
+
+# --- Build the Graph (Updated with Triage) ---
+workflow = StateGraph(AgentState)
+workflow.add_node("triage", run_triage_agent)
+workflow.add_node("memory_retriever", run_memory_retrieval)
+# ... add all other nodes
+workflow.add_node("intent_agent", run_intent_agent)
+workflow.add_node("pm_agent", run_pm_agent)
+workflow.add_node("experimenter_agent", run_experimenter_agent)
+workflow.add_node("synthesis_agent", run_synthesis_agent)
+workflow.add_node("qa_agent", run_qa_agent)
+workflow.add_node("archivist_agent", run_archivist_agent)
+workflow.add_node("disclaimer_agent", run_disclaimer_agent)
+
+# NEW Triage Logic
+# We now have two separate graphs that are conditionally called by the app
+# 1. A simple Triage graph
+triage_workflow = StateGraph(AgentState)
+triage_workflow.add_node("triage", run_triage_agent)
+triage_workflow.set_entry_point("triage")
+triage_app = triage_workflow.compile()
+
+
+# 2. Planner-only graph
+planner_workflow = StateGraph(AgentState)
+planner_workflow.add_node("planner", run_planner_agent)
+planner_workflow.set_entry_point("planner")
+planner_app = planner_workflow.compile()
+
+
+# 3. Full execution graph
+main_workflow = StateGraph(AgentState)
+main_workflow.add_node("memory_retriever", run_memory_retrieval)
+main_workflow.add_node("intent_agent", run_intent_agent)
+main_workflow.add_node("pm_agent", run_pm_agent)
+main_workflow.add_node("experimenter_agent", run_experimenter_agent)
+main_workflow.add_node("synthesis_agent", run_synthesis_agent)
+main_workflow.add_node("qa_agent", run_qa_agent)
+main_workflow.add_node("archivist_agent", run_archivist_agent)
+main_workflow.add_node("disclaimer_agent", run_disclaimer_agent)
+
+main_workflow.set_entry_point("memory_retriever")
+main_workflow.add_edge("memory_retriever", "intent_agent")
+main_workflow.add_edge("intent_agent", "pm_agent")
+main_workflow.add_edge("experimenter_agent", "synthesis_agent")
+main_workflow.add_edge("synthesis_agent", "qa_agent")
+main_workflow.add_edge("archivist_agent", END)
+main_workflow.add_edge("disclaimer_agent", END)
+
+main_workflow.add_conditional_edges("pm_agent", should_run_experiment)
+main_workflow.add_conditional_edges("qa_agent", should_continue, {
+    "archivist_agent": "archivist_agent",
+    "pm_agent": "pm_agent",
+    "disclaimer_agent": "disclaimer_agent"
+})
+main_app = main_workflow.compile()

logging_config.py

@@ -0,0 +1,35 @@
+# logging_config.py (Corrected with UTF-8 encoding)
+
+import logging
+import sys
+import os
+
+def setup_logging():
+    """Configures structured logging for the AI Lab."""
+    os.makedirs("logs", exist_ok=True)
+    
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] [%(name)s]: %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+        handlers=[
+            # Force UTF-8 encoding for the log file
+            logging.FileHandler("logs/ai_lab_run.log", mode='w', encoding='utf-8'),
+            # Force UTF-8 encoding for the console stream
+            logging.StreamHandler(sys.stdout)
+        ]
+    )
+    
+    # Forcing UTF-8 on the console handler is critical for Windows
+    logging.getLogger().handlers[-1].setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] [%(name)s]: %(message)s"))
+    logging.getLogger().handlers[-1].encoding = 'utf-8'
+
+
+    # Silence overly verbose libraries to keep the log clean
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    logging.getLogger("urllib3").setLevel(logging.WARNING)
+    logging.getLogger("sentence_transformers").setLevel(logging.WARNING)
+
+def get_logger(name):
+    """A helper to get a logger instance for a specific module."""
+    return logging.getLogger(name)

memory/faiss.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3bede98be9f381efd5413f20d96dbea5e53ca588b2811ead62079ea6a3880816
+size 3104

memory_manager.py

@@ -0,0 +1,55 @@
+import os
+import shutil
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain.docstore.document import Document
+
+# --- Configuration ---
+MEMORY_DIR = "memory"
+INDEX_NAME = "faiss"
+MODEL_NAME = "all-MiniLM-L6-v2"
+
+class MemoryManager:
+    def __init__(self):
+        self.embeddings = HuggingFaceEmbeddings(model_name=MODEL_NAME)
+        self.vector_store = self._load_or_create_vector_store()
+
+    def _load_or_create_vector_store(self):
+        """Loads FAISS index or creates a new one, handling potential corruption."""
+        index_path = os.path.join(MEMORY_DIR, f"{INDEX_NAME}.faiss")
+        if os.path.exists(index_path):
+            try:
+                print("🧠 Loading existing memory from disk...")
+                return FAISS.load_local(
+                    folder_path=MEMORY_DIR, 
+                    embeddings=self.embeddings,
+                    index_name=INDEX_NAME,
+                    allow_dangerous_deserialization=True
+                )
+            except Exception as e:
+                print(f"⚠️ Error loading memory index: {e}. Rebuilding index.")
+                shutil.rmtree(MEMORY_DIR)
+                os.makedirs(MEMORY_DIR, exist_ok=True)
+                return self._create_new_index()
+        else:
+            print("🧠 No existing memory found. Creating a new one.")
+            return self._create_new_index()
+
+    def _create_new_index(self):
+        """Creates a fresh, empty FAISS index."""
+        dummy_doc = [Document(page_content="Initial memory entry.")]
+        vs = FAISS.from_documents(dummy_doc, self.embeddings)
+        vs.save_local(folder_path=MEMORY_DIR, index_name=INDEX_NAME)
+        return vs
+
+    def add_to_memory(self, text_to_add: str, metadata: dict):
+        print(f"📝 Adding new memory: {text_to_add[:100]}...")
+        doc = Document(page_content=text_to_add, metadata=metadata)
+        self.vector_store.add_documents([doc])
+        self.vector_store.save_local(folder_path=MEMORY_DIR, index_name=INDEX_NAME)
+
+    def retrieve_relevant_memories(self, query: str, k: int = 5) -> list[Document]:
+        print(f"🔍 Searching memory for: {query}")
+        return self.vector_store.similarity_search(query, k=k)
+
+memory_manager = MemoryManager()

outputs/last_run_flow.md

@@ -0,0 +1,10 @@
+# Last Run Execution Flow
+
+```mermaid
+graph TD;
+    Memory_Retriever --> Intent_Agent;
+    Intent_Agent --> PM_Agent;
+    PM_Agent --> Synthesis_Agent;
+    Synthesis_Agent --> QA_Agent;
+    QA_Agent --> Archivist_Agent;
+```

requirements.txt

@@ -0,0 +1,15 @@
+# Web Framework & Server
+flask
+
+# Core LangChain & Agent Framework
+langchain
+langgraph
+langchain_openai
+
+# Vector Store & Embeddings
+faiss-cpu
+langchain-huggingface
+sentence-transformers
+
+# Environment Variables
+python-dotenv

static/script.js

@@ -0,0 +1,152 @@
+// static/script.js (Updated to handle greeting triage)
+
+document.addEventListener('DOMContentLoaded', () => {
+    const sendBtn = document.getElementById('send-btn');
+    const messageInput = document.getElementById('message-input');
+    const chatWindow = document.getElementById('chat-window');
+    let originalUserMessage = '';
+    let currentEstimate = {};
+
+    const appendMessage = (sender, message, isHtml = false) => {
+        const senderClass = sender === 'You' ? 'user-message' : 'agent-message';
+        const messageDiv = document.createElement('div');
+        messageDiv.classList.add('message', senderClass);
+        const contentDiv = document.createElement('div');
+        const senderStrong = document.createElement('strong');
+        senderStrong.textContent = `${sender}:`;
+        contentDiv.appendChild(senderStrong);
+        const messageP = document.createElement('p');
+        if (isHtml) {
+            messageP.innerHTML = message;
+        } else {
+            messageP.textContent = message;
+        }
+        contentDiv.appendChild(messageP);
+        messageDiv.appendChild(contentDiv);
+        chatWindow.appendChild(messageDiv);
+        chatWindow.scrollTop = chatWindow.scrollHeight;
+        return messageDiv;
+    };
+
+    const showApprovalDialog = (estimate) => {
+        // ... (This function is unchanged)
+        currentEstimate = estimate;
+        const planHtml = `
+            <p>Here is my plan to address your request:</p>
+            <ul>${estimate.plan.map(step => `<li>${step}</li>`).join('')}</ul>
+            <p>I estimate this will cost ~<strong>$${estimate.estimated_cost_usd}</strong> (for ${estimate.max_loops_initial + 1} attempts).</p>
+            <div class="approval-form">
+                <label for="budget-input">Set your maximum budget ($):</label>
+                <input type="number" id="budget-input" step="0.05" min="0.05" value="${estimate.estimated_cost_usd}">
+                <div class="approval-buttons">
+                    <button id="proceed-btn">✅ Proceed with Budget</button>
+                    <button id="cancel-btn">❌ Cancel</button>
+                </div>
+            </div>
+        `;
+        const dialog = appendMessage('Agent', planHtml, true);
+
+        document.getElementById('proceed-btn').addEventListener('click', () => {
+            const userBudget = document.getElementById('budget-input').value;
+            dialog.remove();
+            appendMessage('Agent', `Budget of $${userBudget} approved. Starting the main process...`);
+            executeMainTask(userBudget);
+});
+
+        document.getElementById('cancel-btn').addEventListener('click', () => {
+            dialog.remove();
+            appendMessage('Agent', 'Task cancelled.');
+            enableInput();
+        });
+    };
+    
+    const disableInput = () => { /* ... unchanged ... */ };
+    const enableInput = () => { /* ... unchanged ... */ };
+    
+    const startEstimation = async () => {
+        originalUserMessage = messageInput.value.trim();
+        if (!originalUserMessage) return;
+
+        appendMessage('You', originalUserMessage);
+        messageInput.value = '';
+        disableInput();
+        
+        const thinkingMessage = appendMessage('Agent', 'Thinking...');
+
+        try {
+            const response = await fetch('/estimate', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ message: originalUserMessage })
+            });
+            const result = await response.json();
+            
+            thinkingMessage.remove();
+
+            if (result.error) {
+                appendMessage('Agent', `Error during planning: ${result.error}`);
+                enableInput();
+            } else if (result.is_greeting) {
+                // NEW: Handle the greeting case
+                appendMessage('Agent', result.response);
+                enableInput();
+            } else {
+                // It's a complex task, show the approval dialog
+                showApprovalDialog(result);
+            }
+        } catch (error) {
+            console.error('Error:', error);
+            thinkingMessage.remove();
+            appendMessage('Agent', 'Sorry, I encountered an error during estimation.');
+            enableInput();
+        }
+    };
+    
+    const executeMainTask = async (userBudget) => { /* ... unchanged ... */ };
+    
+    // ... All other functions and event listeners are unchanged ...
+    const disableInput = () => {
+        messageInput.disabled = true;
+        sendBtn.disabled = true;
+    };
+
+    const enableInput = () => {
+        messageInput.disabled = false;
+        sendBtn.disabled = false;
+        messageInput.focus();
+    };
+
+    const executeMainTask = async (userBudget) => {
+        disableInput();
+        const thinkingMessage = appendMessage('Agent', 'Executing task within budget...');
+
+        try {
+            const response = await fetch('/chat', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    message: originalUserMessage,
+                    user_budget: userBudget,
+                    cost_per_loop: currentEstimate.cost_per_loop_usd
+                })
+            });
+            const data = await response.json();
+            thinkingMessage.remove();
+            appendMessage('Agent', data.response, true);
+        } catch (error) {
+            console.error('Error:', error);
+            thinkingMessage.remove();
+            appendMessage('Agent', 'Sorry, I encountered an error during execution.');
+        } finally {
+            enableInput();
+        }
+    };
+
+    sendBtn.addEventListener('click', startEstimation);
+    messageInput.addEventListener('keydown', (event) => {
+        if (event.key === 'Enter' && !event.shiftKey) {
+            event.preventDefault();
+            startEstimation();
+        }
+    });
+});

static/style.css

@@ -0,0 +1,26 @@
+body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif; display: flex; height: 100vh; margin: 0; background-color: #f8f9fa; }
+.container { display: flex; width: 100%; height: 100%; }
+.sidebar { width: 250px; background-color: #e9ecef; padding: 15px; border-right: 1px solid #dee2e6; display: flex; flex-direction: column; }
+.sidebar h3 { font-size: 1rem; color: #495057; margin-top: 0; }
+.sidebar button { width: 100%; padding: 10px; border: none; border-radius: 5px; background-color: #007bff; color: white; cursor: pointer; margin-bottom: 15px; }
+.sidebar hr { border: none; border-top: 1px solid #dee2e6; margin: 15px 0; }
+.main-chat { flex-grow: 1; display: flex; flex-direction: column; background-color: #ffffff; }
+#chat-window { flex-grow: 1; padding: 20px; overflow-y: auto; }
+.chat-input { display: flex; padding: 10px; border-top: 1px solid #dee2e6; background-color: #f1f3f5; }
+textarea { flex-grow: 1; padding: 10px; border-radius: 8px; border: 1px solid #ced4da; resize: none; font-size: 1rem; line-height: 1.5; }
+textarea:focus { outline: none; border-color: #80bdff; box-shadow: 0 0 0 0.2rem rgba(0,123,255,.25); }
+#send-btn { padding: 10px 15px; margin-left: 10px; border: none; background-color: #007bff; color: white; border-radius: 8px; cursor: pointer; font-weight: bold; }
+#send-btn:disabled { background-color: #6c757d; cursor: not-allowed; }
+.message { margin-bottom: 15px; max-width: 80%; }
+.message strong { display: block; margin-bottom: 5px; color: #212529; }
+.message p { margin: 0; padding: 10px 15px; border-radius: 12px; line-height: 1.6; }
+.user-message { align-self: flex-end; margin-left: auto; }
+.user-message p { background-color: #007bff; color: white; }
+.agent-message { align-self: flex-start; }
+.agent-message p { background-color: #e9ecef; color: #212529; }
+.approval-form { background-color: #f8f9fa; border: 1px solid #dee2e6; border-radius: 8px; padding: 15px; margin-top: 10px; }
+.approval-form label { display: block; margin-bottom: 5px; font-weight: bold; }
+.approval-form input { width: 100px; padding: 5px; border-radius: 5px; border: 1px solid #ced4da; margin-bottom: 10px; }
+.approval-buttons button { padding: 8px 12px; border: none; border-radius: 5px; cursor: pointer; margin-right: 10px; }
+#proceed-btn { background-color: #28a745; color: white; }
+#cancel-btn { background-color: #dc3545; color: white; }

templates/index.html

@@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Autonomous AI Lab</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+</head>
+<body>
+    <div class="container">
+        <div class="sidebar">
+            <h3>Conversations</h3>
+            <button id="new-chat-btn">+ New Chat</button>
+            <ul id="chat-list"></ul>
+            <hr>
+            <h3>Artifacts</h3>
+            <input type="file" id="file-upload">
+            <div id="file-list"></div>
+        </div>
+        <div class="main-chat">
+            <div id="chat-window">
+                <div class="message agent-message">
+                    <div><strong>Agent:</strong><p>Welcome to the Autonomous AI Lab. How can I help you today?</p></div>
+                </div>
+            </div>
+            <div class="chat-input">
+                <textarea id="message-input" placeholder="Ask a question or describe a task..."></textarea>
+                <button id="send-btn">Send</button>
+            </div>
+        </div>
+    </div>
+    <script src="{{ url_for('static', filename='script.js') }}"></script>
+</body>
+</html>

test_agent.py

@@ -0,0 +1,35 @@
+import os
+from dotenv import load_dotenv
+from graph import AgentState, run_pm_agent, run_synthesis_agent
+
+# Load environment variables from .env file
+load_dotenv()
+
+print("---🔬 Interactive Agent Test Bed ---")
+
+# 1. Create a mock state to test the PM Agent
+mock_state_for_pm = AgentState(
+    userInput="How do I fine-tune a Llama-3 model on a custom dataset?",
+    coreObjectivePrompt="Provide a detailed, step-by-step guide for fine-tuning a Llama-3 model on a custom dataset, including code examples and best practices.",
+    retrievedMemory="Memory: Fine-tuning requires a powerful GPU and careful data preparation.",
+    qaFeedback=None,
+    execution_path=[]
+)
+
+print("\n--- Testing PM Agent ---")
+pm_output = run_pm_agent(mock_state_for_pm)
+pm_plan = pm_output.get('pmPlan', {})
+print(f"PM Plan Generated: {pm_plan}")
+
+
+# 2. Use the output from the PM test to test the Synthesis Agent
+if pm_plan:
+    mock_state_for_synthesis = AgentState(
+        coreObjectivePrompt=mock_state_for_pm['coreObjectivePrompt'],
+        pmPlan=pm_plan,
+        experimentResults=None # Mocking that no experiment was run
+    )
+
+    print("\n--- Testing Synthesis Agent ---")
+    synthesis_output = run_synthesis_agent(mock_state_for_synthesis)
+    print(f"Synthesized Draft (first 300 chars): {synthesis_output['draftResponse'][:300]}...")

utils.py

@@ -0,0 +1,13 @@
+def generate_mermaid_diagram(path: list) -> str:
+    """Generates Mermaid.js syntax for the execution path."""
+    if not path:
+        return ""
+    
+    diagram = "graph TD;\n"
+    # Replace spaces with underscores for valid Mermaid node names
+    path_nodes = [p.replace(' ', '_') for p in path]
+    
+    for i in range(len(path_nodes) - 1):
+        diagram += f"    {path_nodes[i]} --> {path_nodes[i+1]};\n"
+        
+    return diagram