Cleanup: remove junk files, update .gitignore

.gitignore

@@ -1,4 +1,37 @@
-__pycache__/ 
-*.pyc 
-*.pyo 
-token.txt 
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.egg-info/
+dist/
+build/
+*.egg
+
+# Environments
+venv/
+.venv/
+env/
+.env
+
+# Jupyter
+.ipynb_checkpoints/
+*.ipynb_checkpoints
+
+# Secrets
+token.txt
+*.token
+.env*
+
+# Lock files (not needed for this project)
+uv.lock
+
+# OS
+.DS_Store
+Thumbs.db
+
+# One-off scripts (not part of environment)
+fix_*.py
+inference.py
+plot_reward_curve.py
+reward_curve.png

fix_metadata.py

@@ -1,12 +0,0 @@
-content = open('server/support_environment.py', 'r', encoding='utf-8').read()
-content = content.replace('\tdef get_metadata', '    def get_metadata')
-content = content.replace('\t        from openenv', '        from openenv')
-content = content.replace('\t        return EnvironmentMetadata', '        return EnvironmentMetadata')
-content = content.replace('\t            name=', '            name=')
-content = content.replace('\t            description=', '            description=')
-content = content.replace('\t            version=', '            version=')
-content = content.replace('\t            author=', '            author=')
-content = content.replace('\t            documentation_url=', '            documentation_url=')
-content = content.replace('\t        )', '        )')
-open('server/support_environment.py', 'w', encoding='utf-8').write(content)
-print('Done!')

fix_readme.py

@@ -1,100 +0,0 @@
-f = open('README.md', 'w', encoding='utf-8')
-f.write('---\n')
-f.write('title: Support Ticket Env\n')
-f.write('emoji: \U0001f3ab\n')
-f.write('colorFrom: blue\n')
-f.write('colorTo: green\n')
-f.write('sdk: docker\n')
-f.write('tags:\n')
-f.write('  - openenv\n')
-f.write('pinned: false\n')
-f.write('---\n\n')
-f.write('# Customer Support Ticket Resolution Environment\n\n')
-f.write('A real-world [OpenEnv](https://github.com/meta-pytorch/OpenEnv) environment where an AI agent acts as a customer support executive, triaging and resolving incoming tickets.\n\n')
-f.write('## Overview\n\n')
-f.write('Customer support triage is one of the most common real-world tasks for AI agents. Every company handles thousands of tickets daily. Getting the classification wrong routes the ticket to the wrong team. Choosing the wrong action has direct business impact. This environment trains agents to handle exactly this challenge.\n\n')
-f.write('## Quick Start\n\n')
-f.write('```python\n')
-f.write('from support_ticket_env import SupportAction, SupportTicketEnv\n\n')
-f.write('with SupportTicketEnv(base_url="https://algocore-support-ticket-env.hf.space").sync() as env:\n')
-f.write('    # Task 1 - Classify a ticket\n')
-f.write('    result = env.reset(task_id=1, seed=42)\n')
-f.write('    print(result.observation.ticket_text)\n\n')
-f.write('    result = env.step(SupportAction(action_type="classify", category="billing"))\n')
-f.write('    print(result.reward)  # 1.0 if correct\n')
-f.write('```\n\n')
-f.write('## Tasks\n\n')
-f.write('| Task | Difficulty | Description | Score Range |\n')
-f.write('|------|-----------|-------------|-------------|\n')
-f.write('| Task 1 | Easy | Classify ticket into correct category | 0.0 - 1.0 |\n')
-f.write('| Task 2 | Medium | Classify then choose correct action | 0.0 - 1.0 |\n')
-f.write('| Task 3 | Hard | Resolve a full queue of 3 tickets | 0.0 - 1.0 |\n\n')
-f.write('## Action Space\n\n')
-f.write('Actions are `SupportAction` Pydantic objects:\n\n')
-f.write('| Field | Type | Required | Values |\n')
-f.write('|-------|------|----------|--------|\n')
-f.write('| `action_type` | str | always | `classify` / `reply` / `escalate` / `close` |\n')
-f.write('| `category` | str | for classify | `billing` / `technical` / `account` / `general` / `refund` |\n')
-f.write('| `reply_text` | str | for reply | free text |\n')
-f.write('| `reason` | str | optional | free text |\n\n')
-f.write('## Observation Space\n\n')
-f.write('| Field | Type | Description |\n')
-f.write('|-------|------|-------------|\n')
-f.write('| `ticket_id` | str | Unique ticket ID |\n')
-f.write('| `ticket_text` | str | Customer message |\n')
-f.write('| `task_id` | int | 1, 2, or 3 |\n')
-f.write('| `current_category` | str | Category assigned so far |\n')
-f.write('| `resolved` | bool | Whether ticket is resolved |\n')
-f.write('| `step_count` | int | Steps taken this episode |\n')
-f.write('| `feedback` | str | Human-readable feedback |\n')
-f.write('| `reward` | float | Reward signal |\n')
-f.write('| `done` | bool | Episode finished |\n\n')
-f.write('## Reward Function\n\n')
-f.write('Rewards provide partial progress signals throughout the trajectory:\n\n')
-f.write('- **Task 1:** 1.0 for correct category, 0.0 for wrong\n')
-f.write('- **Task 2:** 1.0 correct action, 0.5 defensible alternative, 0.3 classification only\n')
-f.write('- **Task 3:** 0.20 classification + 0.40 action + 0.25 reply quality + 0.15 efficiency bonus\n')
-f.write('- **Penalty:** -0.05 per step over 10 (loop deterrent)\n\n')
-f.write('## Project Structure\n\n')
-f.write('```\n')
-f.write('support_ticket_env/\n')
-f.write('├── __init__.py          # Package exports\n')
-f.write('├── models.py            # SupportAction, SupportObservation, SupportState\n')
-f.write('├── tickets.py           # Ticket dataset with ground-truth labels\n')
-f.write('├── graders.py           # Reward/grader functions for all 3 tasks\n')
-f.write('├── client.py            # EnvClient subclass\n')
-f.write('├── baseline.py          # Baseline inference script\n')
-f.write('├── openenv.yaml         # Environment metadata\n')
-f.write('├── Dockerfile           # Container definition\n')
-f.write('└── server/\n')
-f.write('    ├── app.py           # FastAPI entry point\n')
-f.write('    └── support_environment.py  # Environment logic\n')
-f.write('```\n\n')
-f.write('## Setup\n\n')
-f.write('```bash\n')
-f.write('# Install dependencies\n')
-f.write('pip install openenv-core fastapi uvicorn pydantic gradio openai\n\n')
-f.write('# Run locally\n')
-f.write('cd support_ticket_env\n')
-f.write('uvicorn server.app:app --host 0.0.0.0 --port 7860\n\n')
-f.write('# Docker\n')
-f.write('docker build -t support-ticket-env .\n')
-f.write('docker run -p 7860:7860 support-ticket-env\n\n')
-f.write('# Run tests\n')
-f.write('python run_tests.py\n')
-f.write('```\n\n')
-f.write('## Baseline Scores\n\n')
-f.write('Measured with `gpt-4o-mini`, seeds `[42, 7, 123]`:\n\n')
-f.write('| Task | Avg Score |\n')
-f.write('|------|-----------|\n')
-f.write('| Task 1 - Classification | 0.87 |\n')
-f.write('| Task 2 - Action Selection | 0.71 |\n')
-f.write('| Task 3 - Full Resolution | 0.58 |\n')
-f.write('| **Overall** | **0.72** |\n\n')
-f.write('## Links\n\n')
-f.write('- **HuggingFace Space:** https://huggingface.co/spaces/AlgoCore/support-ticket-env\n')
-f.write('- **GitHub:** https://github.com/TryingHardToBeDeveloper/support-ticket-env\n')
-f.write('- **OpenEnv Docs:** https://meta-pytorch.org/OpenEnv/\n\n')
-f.write('## License\n\nMIT\n')
-f.close()
-print('Done!')

inference.py

@@ -1,267 +0,0 @@
-"""
-inference.py - Support Ticket Resolution Environment
-Follows mandatory [START] [STEP] [END] logging format.
-"""
-
-import asyncio
-import os
-import sys
-import json
-import re
-from typing import List, Optional
-
-ROOT = os.path.dirname(os.path.abspath(__file__))
-sys.path.insert(0, ROOT)
-
-from openai import OpenAI
-from support_ticket_env.server.support_environment import SupportTicketEnvironment
-from support_ticket_env.models import SupportAction
-
-# ── Environment variables ────────────────────────────────────────
-API_KEY      = os.getenv("HF_TOKEN") or os.getenv("API_KEY")
-API_BASE_URL = os.getenv("API_BASE_URL") or "https://router.huggingface.co/v1"
-MODEL_NAME   = os.getenv("MODEL_NAME") or "Qwen/Qwen2.5-72B-Instruct"
-TASK_NAME    = "support-ticket-resolution"
-BENCHMARK    = "support_ticket_env"
-MAX_STEPS    = 10
-SUCCESS_SCORE_THRESHOLD = 0.5
-
-VALID_CATEGORIES = ["billing", "technical", "account", "general", "refund"]
-VALID_ACTIONS    = ["classify", "reply", "escalate", "close"]
-
-SYSTEM_PROMPT = """You are a customer support AI agent handling tickets.
-You receive a JSON with ticket_text, task_id, feedback, and current_category.
-
-Respond ONLY with a JSON object (no markdown, no explanation):
-{
-  "action_type": "classify" | "reply" | "escalate" | "close",
-  "category": "billing" | "technical" | "account" | "general" | "refund",
-  "reply_text": "...",
-  "reason": "..."
-}
-
-Rules:
-- For task 1: use action_type=classify and pick the correct category.
-- For task 2: first classify, then on next step reply/escalate/close.
-- For task 3: classify each ticket then resolve it (classify first, then action).
-- category is ONLY needed when action_type=classify.
-- reply_text is ONLY needed when action_type=reply.
-
-Category detection rules:
-- billing: mentions charge, invoice, payment, bill, subscription, price, cost, fee
-- technical: mentions error, bug, crash, not working, broken, API, 500, upload, fail
-- account: mentions login, password, account, access, sign in, email, cancel, subscription cancel
-- refund: mentions refund, return, money back, reimburse, unused
-- general: mentions hours, phone, contact, business hours, information
-
-Action rules:
-- technical tickets -> escalate (include 'escalate' and 'engineering' in reason)
-- general tickets that are resolved/thank you -> close
-- all others -> reply
-
-When replying, your reply_text MUST include relevant keywords:
-- billing reply: include words like 'charge', 'invoice', 'payment', 'billing'
-- account reply: include words like 'account', 'password', 'login', 'subscription'
-- refund reply: include words like 'refund', 'return', 'credit', 'process'
-- general reply: include words like 'hours', 'contact', 'phone', 'information'
-- technical escalation reason: include 'engineering', 'escalate', 'bug', 'error'
-"""
-
-
-def log_start(task: str, env: str, model: str) -> None:
-    print(f"[START] task={task} env={env} model={model}", flush=True)
-
-
-def log_step(step: int, action: str, reward: float, done: bool, error: Optional[str]) -> None:
-    error_val = error if error else "null"
-    done_val = str(done).lower()
-    print(
-        f"[STEP] step={step} action={action} reward={reward:.2f} done={done_val} error={error_val}",
-        flush=True,
-    )
-
-
-def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
-    rewards_str = ",".join(f"{r:.2f}" for r in rewards)
-    print(f"[END] success={str(success).lower()} steps={steps} score={score:.3f} rewards={rewards_str}", flush=True)
-
-
-def parse_response(text: str) -> dict:
-    text = text.strip()
-    text = re.sub(r"^```(?:json)?\s*", "", text)
-    text = re.sub(r"\s*```$", "", text)
-    try:
-        return json.loads(text)
-    except Exception:
-        match = re.search(r"\{.*\}", text, re.DOTALL)
-        if match:
-            return json.loads(match.group())
-        raise
-
-
-CATEGORY_KEYWORDS = {
-    "billing": ["charge", "invoice", "payment", "bill", "refund", "subscription", "price", "cost", "fee", "money"],
-    "technical": ["error", "bug", "crash", "not working", "broken", "issue", "problem", "fail", "500", "api"],
-    "account": ["login", "password", "account", "access", "sign in", "email", "username", "cancel"],
-    "refund": ["refund", "return", "money back", "reimburse", "cancel order"],
-    "general": ["hours", "contact", "phone", "help", "question", "info", "support"],
-}
-
-def rule_based_action(obs) -> dict:
-    """Simple deterministic fallback agent — no API needed."""
-    text = obs.ticket_text.lower()
-    # Classify by keywords
-    if not obs.current_category:
-        best_cat = "general"
-        best_score = 0
-        for cat, keywords in CATEGORY_KEYWORDS.items():
-            score = sum(1 for kw in keywords if kw in text)
-            if score > best_score:
-                best_score = score
-                best_cat = cat
-        return {"action_type": "classify", "category": best_cat}
-    # After classification — choose action based on category
-    cat = obs.current_category
-    if cat == "technical":
-        return {"action_type": "escalate", "reason": "Technical issue requires engineering team"}
-    elif cat == "general":
-        return {"action_type": "close", "reason": "General inquiry resolved"}
-    else:
-        return {
-            "action_type": "reply",
-            "reply_text": f"Thank you for contacting us about your {cat} issue. We are looking into it and will resolve it shortly."
-        }
-
-
-def get_model_action(client: OpenAI, obs, history: List[str]) -> dict:
-    """Try LLM first, fall back to rule-based if API unavailable."""
-    if not API_KEY:
-        return rule_based_action(obs)
-    user_prompt = json.dumps({
-        "ticket_id": obs.ticket_id,
-        "ticket_text": obs.ticket_text,
-        "task_id": obs.task_id,
-        "current_category": obs.current_category,
-        "step_count": obs.step_count,
-        "feedback": obs.feedback,
-    })
-    messages = [
-        {"role": "system", "content": SYSTEM_PROMPT},
-        {"role": "user", "content": user_prompt},
-    ]
-    try:
-        completion = client.chat.completions.create(
-            model=MODEL_NAME,
-            messages=messages,
-            temperature=0.0,
-            max_tokens=256,
-            stream=False,
-        )
-        text = (completion.choices[0].message.content or "").strip()
-        return parse_response(text)
-    except Exception as exc:
-        print(f"[DEBUG] Model request failed, using fallback: {exc}", flush=True)
-        return rule_based_action(obs)
-    user_prompt = json.dumps({
-        "ticket_id": obs.ticket_id,
-        "ticket_text": obs.ticket_text,
-        "task_id": obs.task_id,
-        "current_category": obs.current_category,
-        "step_count": obs.step_count,
-        "feedback": obs.feedback,
-    })
-    messages = [
-        {"role": "system", "content": SYSTEM_PROMPT},
-        {"role": "user", "content": user_prompt},
-    ]
-    try:
-        completion = client.chat.completions.create(
-            model=MODEL_NAME,
-            messages=messages,
-            temperature=0.0,
-            max_tokens=256,
-            stream=False,
-        )
-        text = (completion.choices[0].message.content or "").strip()
-        return parse_response(text)
-    except Exception as exc:
-        print(f"[DEBUG] Model request failed: {exc}", flush=True)
-        return {"action_type": "classify", "category": "general"}
-
-
-def run_task(task_id: int, seed: int, client: OpenAI) -> float:
-    env = SupportTicketEnvironment()
-    obs = env.reset(task_id=task_id, seed=seed)
-
-    history: List[str] = []
-    rewards: List[float] = []
-    steps_taken = 0
-    score = 0.0
-    success = False
-
-    log_start(task=f"{TASK_NAME}-task{task_id}", env=BENCHMARK, model=MODEL_NAME)
-
-    try:
-        for step in range(1, MAX_STEPS + 1):
-            if obs.done:
-                break
-
-            action_dict = get_model_action(client, obs, history)
-            action_str = f"{action_dict.get('action_type','?')}"
-            if action_dict.get("category"):
-                action_str += f"/{action_dict['category']}"
-
-            error = None
-            try:
-                action = SupportAction(**action_dict)
-                obs = env.step(action)
-                reward = obs.reward or 0.0
-                done = obs.done
-            except Exception as e:
-                reward = 0.0
-                done = False
-                error = str(e)
-
-            rewards.append(reward)
-            steps_taken = step
-
-            log_step(step=step, action=action_str, reward=reward, done=done, error=error)
-
-            history.append(f"Step {step}: {action_str} -> reward {reward:+.2f}")
-
-            if done:
-                break
-
-        total = sum(rewards)
-        score = min(max(round(total / max(steps_taken, 1), 3), 0.0), 1.0)
-        success = score >= SUCCESS_SCORE_THRESHOLD
-
-    finally:
-        log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
-
-    return score
-
-
-def main() -> None:
-    if not API_KEY:
-        print("[DEBUG] HF_TOKEN not set", flush=True)
-        sys.exit(1)
-
-    client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
-
-    all_scores = {}
-    for task_id in [1, 2, 3]:
-        scores = []
-        for seed in [42, 7, 123, 0, 99]:
-            score = run_task(task_id, seed, client)
-            scores.append(score)
-        avg = round(sum(scores) / len(scores), 4)
-        all_scores[f"task{task_id}"] = avg
-        print(f"[DEBUG] Task {task_id} avg score: {avg}", flush=True)
-
-    overall = round(sum(all_scores.values()) / len(all_scores), 4)
-    print(f"[DEBUG] Overall avg score: {overall}", flush=True)
-
-
-if __name__ == "__main__":
-    main()

plot_reward_curve.py

@@ -1,171 +0,0 @@
-"""
-plot_reward_curve.py — Reward curve bar chart for hackathon pitch.
-Shows Before (rule-based baseline) vs After (LLM agent) scores for Task 1/2/3.
-
-Usage:
-    python plot_reward_curve.py                        # uses hardcoded scores
-    python plot_reward_curve.py --run-inference        # runs inference.py first (needs HF_TOKEN)
-
-Output: reward_curve.png  (saved next to this script)
-"""
-
-import os
-import sys
-import subprocess
-import json
-import re
-import argparse
-
-import matplotlib
-matplotlib.use("Agg")  # headless — safe on all machines
-import matplotlib.pyplot as plt
-import matplotlib.patches as mpatches
-import numpy as np
-
-# ── Baseline scores (rule-based, from session recap) ────────────────────────
-BASELINE = {
-    "Task 1": 0.10,
-    "Task 2": 0.11,
-    "Task 3": 0.26,
-}
-
-# ── After scores — override these after running inference, or use --run-inference
-AFTER = {
-    "Task 1": 0.72,
-    "Task 2": 0.65,
-    "Task 3": 0.54,
-}
-
-
-def run_inference_and_parse() -> dict:
-    """Run inference.py with seeds 42,7,123 and parse [DEBUG] avg lines."""
-    print("[plot] Running inference.py to collect live scores...", flush=True)
-    env = os.environ.copy()
-    result = subprocess.run(
-        [sys.executable, os.path.join(os.path.dirname(__file__), "inference.py")],
-        capture_output=True, text=True, env=env
-    )
-    output = result.stdout + result.stderr
-    print(output, flush=True)
-
-    scores = {}
-    for line in output.splitlines():
-        m = re.search(r"\[DEBUG\] Task (\d) avg score: ([0-9.]+)", line)
-        if m:
-            scores[f"Task {m.group(1)}"] = float(m.group(2))
-
-    if len(scores) < 3:
-        print("[plot] WARNING: Could not parse all 3 task scores. Using hardcoded AFTER values.", flush=True)
-        return AFTER
-    return scores
-
-
-def plot_chart(baseline: dict, after: dict, out_path: str) -> None:
-    tasks = list(baseline.keys())
-    x = np.arange(len(tasks))
-    width = 0.32
-
-    # ── Colours ─────────────────────────────────────────────────────────────
-    COLOR_BEFORE = "#E05A5A"   # warm red
-    COLOR_AFTER  = "#4CAF82"   # teal green
-    BG           = "#1A1A2E"
-    PANEL        = "#16213E"
-    TEXT         = "#E0E0E0"
-    GRID         = "#2A2A4A"
-
-    fig, ax = plt.subplots(figsize=(10, 6))
-    fig.patch.set_facecolor(BG)
-    ax.set_facecolor(PANEL)
-
-    bars_before = ax.bar(x - width/2, [baseline[t] for t in tasks],
-                         width, label="Before (Rule-based)", color=COLOR_BEFORE,
-                         zorder=3, edgecolor="none", linewidth=0)
-    bars_after  = ax.bar(x + width/2, [after[t] for t in tasks],
-                         width, label="After (LLM Agent)", color=COLOR_AFTER,
-                         zorder=3, edgecolor="none", linewidth=0)
-
-    # ── Value labels on bars ─────────────────────────────────────────────────
-    for bar in bars_before:
-        h = bar.get_height()
-        ax.text(bar.get_x() + bar.get_width() / 2, h + 0.015,
-                f"{h:.2f}", ha="center", va="bottom",
-                color=COLOR_BEFORE, fontsize=11, fontweight="bold")
-
-    for bar in bars_after:
-        h = bar.get_height()
-        ax.text(bar.get_x() + bar.get_width() / 2, h + 0.015,
-                f"{h:.2f}", ha="center", va="bottom",
-                color=COLOR_AFTER, fontsize=11, fontweight="bold")
-
-    # ── Improvement arrows ───────────────────────────────────────────────────
-    for i, task in enumerate(tasks):
-        b, a = baseline[task], after[task]
-        delta = a - b
-        mid_x = x[i]
-        arrow_y = max(b, a) + 0.07
-        ax.annotate(
-            f"+{delta:.2f}",
-            xy=(mid_x, arrow_y),
-            ha="center", va="bottom",
-            color="#FFD700", fontsize=10, fontweight="bold",
-        )
-
-    # ── Axes styling ─────────────────────────────────────────────────────────
-    ax.set_xticks(x)
-    ax.set_xticklabels(tasks, color=TEXT, fontsize=13)
-    ax.set_ylim(0, 1.05)
-    ax.set_ylabel("Score (0.0 – 1.0)", color=TEXT, fontsize=12)
-    ax.set_xlabel("Environment Task", color=TEXT, fontsize=12)
-    ax.tick_params(colors=TEXT)
-    ax.yaxis.grid(True, color=GRID, linewidth=0.8, zorder=0)
-    ax.set_axisbelow(True)
-    for spine in ax.spines.values():
-        spine.set_visible(False)
-
-    # ── Title ────────────────────────────────────────────────────────────────
-    ax.set_title(
-        "Support Ticket Env — Reward Improvement\nRule-Based Baseline vs LLM Agent (Qwen2.5-72B)",
-        color=TEXT, fontsize=14, fontweight="bold", pad=16,
-    )
-
-    # ── Legend ───────────────────────────────────────────────────────────────
-    legend = ax.legend(
-        handles=[
-            mpatches.Patch(color=COLOR_BEFORE, label="Before (Rule-based Baseline)"),
-            mpatches.Patch(color=COLOR_AFTER,  label="After  (LLM Agent — Qwen2.5-72B)"),
-        ],
-        facecolor=BG, edgecolor=GRID, labelcolor=TEXT, fontsize=11,
-        loc="upper right",
-    )
-
-    # ── Overall delta watermark ───────────────────────────────────────────────
-    overall_before = round(sum(baseline.values()) / len(baseline), 3)
-    overall_after  = round(sum(after.values())    / len(after),    3)
-    fig.text(
-        0.5, 0.01,
-        f"Overall: {overall_before:.2f} → {overall_after:.2f}  (+{overall_after - overall_before:.2f})",
-        ha="center", color="#FFD700", fontsize=11, fontweight="bold",
-    )
-
-    plt.tight_layout(rect=[0, 0.04, 1, 1])
-    fig.savefig(out_path, dpi=150, bbox_inches="tight", facecolor=BG)
-    print(f"[plot] Chart saved -> {out_path}", flush=True)
-    plt.close(fig)
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Plot reward curve chart")
-    parser.add_argument("--run-inference", action="store_true",
-                        help="Run inference.py first and use live scores as AFTER values")
-    parser.add_argument("--out", default=os.path.join(os.path.dirname(__file__), "reward_curve.png"),
-                        help="Output PNG path (default: reward_curve.png)")
-    args = parser.parse_args()
-
-    after_scores = run_inference_and_parse() if args.run_inference else AFTER
-
-    plot_chart(BASELINE, after_scores, args.out)
-    print("[plot] Done.", flush=True)
-
-
-if __name__ == "__main__":
-    main()