Upload app.py

app.py

@@ -1,46 +1,133 @@
 import os
 import gradio as gr
-# Adjust imports to work when modules are in the repository root.
-# When deploying on Hugging Face, the helper modules live at the top level,
-# so import them directly instead of via a package.
+import openai
+
 from planner import plan_course
 from generators import generate_course_zip
 from searcher import run_web_search
 
-# store chat messages and sources globally
-chat_history = []
-sources = []
+# System prompt guiding the assistant's behaviour during brainstorming
+SYSTEM_PROMPT = (
+    "You are a helpful course planning assistant. Conduct brainstorming with the user "
+    "about their course idea. Offer suggestions, ask clarifying questions, and capture their requirements. "
+    "When the user feels ready, they will click 'Finalize Outline' to create a course plan using all prior "
+    "conversation and gathered resources."
+)
 
-def handle_user_message(message):
-    global chat_history
-    chat_history.append({"role": "user", "content": message})
-    # simple display of conversation
-    return "\n\n".join([m["role"] + ': ' + m["content"] for m in chat_history])
+def chat(user_message, chat_history, chat_pairs, sources, plan):
+    """Handle a user chat message and return updated chat state."""
+    # Ensure OpenAI API key is set
+    openai.api_key = os.getenv("OPENAI_API_KEY")
+    # initialise state variables if they are None
+    if chat_history is None:
+        chat_history = []
+    if chat_pairs is None:
+        chat_pairs = []
+    # append the user's message to the conversation history
+    chat_history.append({"role": "user", "content": user_message})
+    # build messages including system prompt
+    messages = [{"role": "system", "content": SYSTEM_PROMPT}] + chat_history
+    # call OpenAI's ChatCompletion to get assistant's reply
+    response = openai.ChatCompletion.create(
+        model=os.getenv("OPENAI_MODEL", "gpt-5-mini"),
+        messages=messages,
+        temperature=float(os.getenv("TEMPERATURE", "0.7")),
+        max_tokens=int(os.getenv("MAX_OUTPUT_TOKENS", "1024")),
+    )
+    assistant_reply = response["choices"][0]["message"]["content"]
+    # append assistant reply to conversation history
+    chat_history.append({"role": "assistant", "content": assistant_reply})
+    # append pair to display history for Chatbot component
+    chat_pairs.append((user_message, assistant_reply))
+    return chat_pairs, chat_history, chat_pairs, sources, plan
 
-def handle_search(query, num_results=5, domain_filter=""):
-    global sources
+def run_search(query, chat_history, chat_pairs, sources, plan, num_results=5, domain_filter=""):
+    """Execute a web search and update sources list."""
+    # perform search using provided searcher
     results = run_web_search(query, num_results=num_results, domain_filter=domain_filter)
+    if sources is None:
+        sources = []
     sources.extend(results)
-    # return string summarizing sources
-    return "\n".join([f"{r.get('title','')} - {r.get('url','')}" for r in results])
+    # summarise results into a string for display
+    summary_lines = []
+    for r in results:
+        title = r.get("title", "")
+        url = r.get("url", "")
+        summary_lines.append(f"{title} - {url}")
+    summary = "\n".join(summary_lines)
+    return summary, chat_history, chat_pairs, sources, plan
+
+def finalize_outline(chat_history, chat_pairs, sources, plan):
+    """Generate a course outline based on the conversation and collected sources."""
+    if chat_history is None:
+        chat_history = []
+    if sources is None:
+        sources = []
+    # use the planner to create the plan
+    plan_text = plan_course(chat_history, sources)
+    plan = plan_text
+    return plan_text, chat_history, chat_pairs, sources, plan
 
-def handle_generate():
-    plan = plan_course(chat_history, sources)
+def generate_package(plan, sources):
+    """Generate the final course package zip file."""
+    if plan is None or plan == "":
+        # fallback: create a minimal plan if none exists
+        plan = "Course plan is empty."
+    if sources is None:
+        sources = []
     zip_path = generate_course_zip(plan, sources)
     return zip_path
 
 with gr.Blocks() as demo:
-    gr.Markdown("# Course Agent\nChat about your course idea, search for sources, and generate a course package.")
-    message = gr.Textbox(label="Your message")
-    chat_display = gr.Textbox(label="Conversation", interactive=False)
-    search_query = gr.Textbox(label="Search query")
-    domain_filter = gr.Textbox(label="Domain filter (comma-separated)", placeholder=".edu,.gov,acm.org")
+    gr.Markdown(
+        """# Course Creator Agent
+Chat with the assistant to brainstorm your course idea. Use web search to collect resources. When you're ready, click **Finalize Outline** to generate a course plan. Then generate the final course package (ZIP)."""
+    )
+    # Chat interface components
+    chatbot = gr.Chatbot(label="Conversation")
+    msg_input = gr.Textbox(label="Your message", placeholder="Type your message and press Enter", lines=1)
+    # Search controls
+    search_query = gr.Textbox(label="Search query", placeholder="Enter search keywords")
+    domain_filter = gr.Textbox(
+        label="Domain filter (comma-separated)", placeholder=".edu,.gov,acm.org", value=""
+    )
     search_results = gr.Textbox(label="Search results", interactive=False)
+    # Buttons and outputs
+    finalize_btn = gr.Button("Finalize Outline")
+    plan_output = gr.Textbox(label="Course outline", interactive=False)
     generate_btn = gr.Button("Generate Course Package")
     file_output = gr.File(label="course.zip")
-
-    message.submit(handle_user_message, inputs=message, outputs=chat_display)
-    search_query.submit(handle_search, inputs=search_query, outputs=search_results)
-    generate_btn.click(handle_generate, outputs=file_output)
-
-demo.launch()
+    # State variables to keep track of conversation, display pairs, sources and plan
+    state_chat_history = gr.State([])
+    state_chat_pairs = gr.State([])
+    state_sources = gr.State([])
+    state_plan = gr.State("")
+    # Handle chat submission: update chatbot display and states
+    msg_input.submit(
+        chat,
+        inputs=[msg_input, state_chat_history, state_chat_pairs, state_sources, state_plan],
+        outputs=[chatbot, state_chat_history, state_chat_pairs, state_sources, state_plan],
+    ).then(
+        lambda: "", None, None, [], [msg_input]
+    )
+    # Handle search submission: update search results and sources; maintain other states unchanged
+    search_query.submit(
+        lambda q, domain, chat_hist, chat_pairs, srcs, pl: run_search(
+            q, chat_hist, chat_pairs, srcs, pl, num_results=5, domain_filter=domain
+        ),
+        inputs=[search_query, domain_filter, state_chat_history, state_chat_pairs, state_sources, state_plan],
+        outputs=[search_results, state_chat_history, state_chat_pairs, state_sources, state_plan],
+    )
+    # Finalize outline button: generate course plan and store it
+    finalize_btn.click(
+        finalize_outline,
+        inputs=[state_chat_history, state_chat_pairs, state_sources, state_plan],
+        outputs=[plan_output, state_chat_history, state_chat_pairs, state_sources, state_plan],
+    )
+    # Generate course package button
+    generate_btn.click(
+        generate_package,
+        inputs=[state_plan, state_sources],
+        outputs=file_output,
+    )
+    demo.launch()