Upload app.py; module01.txt; requirements.txt

app.py

@@ -0,0 +1,180 @@
+import os
+import gradio as gr
+from pathlib import Path
+
+UNIVERSAL_PROMPT_PATH = "CAT_universal_prompt.txt"
+MODULE_DIR = "modules"  # <-- now using /modules subfolder
+
+from openai import OpenAI
+from dotenv import load_dotenv
+load_dotenv()
+client = OpenAI()
+
+# Type aliases
+from typing import List, cast
+from openai.types.chat import ChatCompletionMessageParam
+
+
+def call_model(system_prompt: str, history: list[dict[str, str]]) -> str:
+    # Build as simple dicts first
+    msgs: list[dict[str, str]] = [{"role": "system", "content": system_prompt}]
+    for m in history:
+        role = m.get("role")
+        content = m.get("content")
+        if role in ("user", "assistant") and isinstance(content, str):
+            msgs.append({"role": role, "content": content})
+
+    # Cast once at the call site to satisfy the SDK types
+    typed_msgs = cast(List[ChatCompletionMessageParam], msgs)
+
+    resp = client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=typed_msgs,
+        temperature=0.4,
+    )
+    return resp.choices[0].message.content or ""
+
+
+def load_text(path: str) -> str:
+    with open(path, "r", encoding="utf-8") as f:
+        return f.read()
+
+def assemble_prompt(universal_prompt_text: str, module_text: str) -> str:
+    def extract(label: str) -> str:
+        marker = label + ":"
+        start = module_text.find(marker)
+        if start == -1:
+            return ""
+        start += len(marker)
+        next_markers = ["\nLEARNING OBJECTIVES:", "\nRUBRIC:", "\nMODULE NAME:"]
+        end_positions = [module_text.find(m, start) for m in next_markers if module_text.find(m, start) != -1]
+        end = min(end_positions) if end_positions else len(module_text)
+        return module_text[start:end].strip()
+
+    learning_objectives = extract("LEARNING OBJECTIVES")
+    rubric = extract("RUBRIC")
+
+    prompt = universal_prompt_text.replace("{LEARNING_OBJECTIVES}", learning_objectives)
+    prompt = prompt.replace("{RUBRIC}", rubric)
+    return prompt
+
+def init_state():
+    return {
+        "assembled_prompt": "",
+        "history": [],
+        "mode": "roleplay",
+        "student_turns": 0,
+        "invited_wrap": False,
+        "mentor_step": 0,
+        "student_name": ""
+    }
+
+def start_session(module_file, student_name=""):
+    state = init_state()
+    state["student_name"] = student_name
+    universal = load_text(UNIVERSAL_PROMPT_PATH)
+    module_text = load_text(Path(MODULE_DIR) / module_file)
+
+    # Give the model the name so it can personalize the dialogue (without overusing it)
+    name_hint = f"\n\n[Student first name: {student_name}. Use it naturally once in the opening; don’t overuse.]" if student_name else ""
+    state["assembled_prompt"] = assemble_prompt(universal, module_text) + name_hint
+
+    state["history"].append({"role": "system", "content": state["assembled_prompt"]})
+    opening = call_model(state["assembled_prompt"], state["history"])
+    state["history"].append({"role": "assistant", "content": opening})
+    return state, state["history"]
+
+def chat(user_msg, state):
+    if not user_msg.strip():
+        return "", state["history"], state
+
+    if state["mode"] == "roleplay":
+        state["student_turns"] += 1
+    state["history"].append({"role": "user", "content": user_msg})
+
+    invite_now = False
+    force_now = False
+
+    if state["mode"] == "roleplay":
+        if state["student_turns"] >= 10:
+            force_now = True
+        elif (7 <= state["student_turns"] <= 9) and not state["invited_wrap"]:
+            invite_now = True
+
+    if state["mode"] == "roleplay" and (invite_now or force_now):
+        if not state["invited_wrap"]:
+            invite = ('Thanks for walking through this with me. We’ve covered a lot. '
+                      'Before we wrap up, is there anything else you’d like me to consider '
+                      'before I give you a preliminary assessment?')
+            state["history"].append({"role": "assistant", "content": invite})
+            state["invited_wrap"] = True
+            return "", state["history"], state
+        else:
+            ack = "I appreciate you sharing that. I’ll take it into account. Let’s step back and review how you approached this situation."
+            state["history"].append({"role": "assistant", "content": ack})
+            state["mode"] = "mentor"
+
+    if state["mode"] == "roleplay" and not state["invited_wrap"]:
+        reply = call_model(state["assembled_prompt"], state["history"])
+        state["history"].append({"role": "assistant", "content": reply})
+        return "", state["history"], state
+
+    if state["mode"] == "mentor":
+        # Step 1: general intro (no assumption of tools)
+        if state.get("mentor_step", 0) == 0:
+            eval_intro = (
+                "Before we wrap up: name two specific concepts, tools, or frameworks you used in this scenario, "
+                "and in one short sentence each say how you applied them. If you didn’t use any, name two insights "
+                "you learned and how you would apply them next time."
+            )
+            state["history"].append({"role": "assistant", "content": eval_intro})
+            state["mentor_step"] = 1
+            return "", state["history"], state
+
+        # Step 2: concise rubric-based evaluation
+        else:
+            eval_request = (
+                "Evaluate the student's performance using the module rubric. Provide these sections: "
+                "Overall rating (Unsatisfactory, Satisfactory, or Excellent) with a one-sentence justification; "
+                'Career competencies; Uniquely human capacities; Argument analysis; Ethical frameworks; ESG awareness; '
+                "Application; Interaction quality; Strength; Area to improve; Advice for next time; Fictional consequence. "
+                "Quote at least one student phrase. Keep the whole evaluation under 180 words and end with 'END OF SCENE'."
+            )
+            state["history"].append({"role": "user", "content": eval_request})
+            reply = call_model(state["assembled_prompt"], state["history"])
+            if "END OF SCENE" not in reply:
+                reply += "\n\nEND OF SCENE"
+            state["history"].append({"role": "assistant", "content": reply})
+            state["mode"] = "done"
+            return "", state["history"], state
+
+
+with gr.Blocks(title="CAT (MVP)") as demo:
+    gr.Markdown("## 😼Conversational Assessment Tool (CAT) — MVP")
+    with gr.Row():
+        module_file = gr.Dropdown(
+            label="Select Module File",
+            choices=[p.name for p in sorted(Path(MODULE_DIR).glob("module*.txt"))],
+            value="module01.txt",
+            interactive=True
+        )
+        name_tb = gr.Textbox(label="Your first name", placeholder="e.g., Maya", value="", interactive=True)
+        start_btn = gr.Button("Start")   # fine to keep inside the row (optional)
+
+    chatbot = gr.Chatbot(label="CAT Conversation", type="messages")
+    user_in = gr.Textbox(label="Your message", placeholder="Type here and press Enter")
+    state = gr.State(init_state())
+
+    def _start(module_name, student_name):
+        student_name = student_name.strip()
+        if not student_name:
+            # Return a valid state object plus a warning message in the chat
+            return init_state(), [{"role": "assistant", "content": "⚠ Please enter your first name before starting."}]
+        st, hist = start_session(module_name, student_name)
+        return st, hist
+
+    start_btn.click(_start, [module_file, name_tb], [state, chatbot])
+    user_in.submit(chat, [user_in, state], [user_in, chatbot, state])
+
+if __name__ == "__main__":
+    demo.launch()

module01.txt

@@ -0,0 +1,18 @@
+MODULE NAME:
+Module 01 — Philosophy, Logic, and Intro to Ethics/ESG
+
+LEARNING OBJECTIVES:
+- Identify and evaluate arguments (premises and conclusions), including detection of formal and informal fallacies.
+- Classify moral arguments according to four traditions: utilitarian (Bentham), rights/duties (Kant), virtue (Aristotle), Care (Gilligan)
+- Understand introductory ESG considerations.
+- Analyze business ethical dilemmas
+- Create your own moral arguments in favor of a business decision
+
+RUBRIC:
+- Career Competencies: Demonstrates critical thinking, clear communication, and professionalism in responses.
+- Uniquely Human Capacities: Shows ethical reasoning, empathy, and perspective-taking when discussing dilemmas.
+- Argument Analysis: Accurately identifies premises and conclusions, evaluates arguments, and detects both formal and informal fallacies.
+- Ethical Frameworks: Correctly classifies moral arguments using utilitarian, rights/duties, virtue, and care traditions; applies them to the scenario.
+- ESG Awareness: Recognizes ESG considerations, including stakeholder interests, values, fairness/justice, and potential impacts.
+- Application: Constructs a coherent and sound moral argument in favor of a business decision within the scenario.
+- Interaction Quality: Maintains clarity and professionalism over ~7–10 student turns (~14–20 total messages).

requirements.txt

@@ -0,0 +1,3 @@
+gradio
+openai
+python-dotenv