Cart environment demo with real 29.6K product catalog

- CART-only interactive testing UI with modern Gradio theme
- Real stratified catalog (29,601 products, 6000 categories) with updated product types
- Prefers pre-built FAISS index, falls back to HF dataset
- Uses Alibaba-NLP/gte-modernbert-base (768-dim) embeddings
- Clean reward banner, persona display, tool execution panel

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

README.md

@@ -1,13 +1,66 @@
 ---
-title: EcomRLVE Gym
-emoji: 🏃
-colorFrom: blue
+title: ShopRLVE Cart Environment
+emoji: 🛒
+colorFrom: green
 colorTo: blue
 sdk: gradio
-sdk_version: 6.11.0
+sdk_version: 5.0.0
 app_file: app.py
 pinned: false
 license: apache-2.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# ShopRLVE-GYM — Cart Environment Demo
+
+Interactive demo for the Cart Building environment from ShopRLVE-GYM.
+
+**You play the AI agent.** A persona-driven simulated customer asks you to find
+and cart specific products. Use catalog search, cart tools, and chat to fulfill
+the request, then submit your answer to see the verifiable reward breakdown.
+
+## How it works
+
+1. **Reset** an episode at your chosen difficulty (0-10)
+2. Read the customer's request in the chat
+3. Use **tools** (search, get_product, get_variants, cart.add, etc.)
+4. **Chat** with the customer for clarification
+5. **Submit** your answer with the product IDs in the cart
+6. See the reward decomposition: r_task (75%), r_eff (15%), r_hall (10%)
+
+## Data requirements
+
+### Primary: Real Catalog (recommended)
+
+The app prefers a **29.6K stratified real product catalog** with a pre-built
+FAISS index using `Alibaba-NLP/gte-modernbert-base` (768-dim) embeddings.
+
+Required files in `data/real_catalog_index/`:
+
+| File | Size | Description |
+|------|------|-------------|
+| `catalog.jsonl` | 7.9 MB | 29,601 products (JSONL: id, title, category, brand, price, rating) |
+| `index.faiss` | 87 MB | FAISS Flat index (768-dim, inner product) |
+| `ids.txt` | 318 KB | Product ID list matching index order |
+| `meta.json` | 138 B | Index metadata |
+
+Build with: `python scripts/build_real_catalog_index.py`
+
+Source: `data/real_product_catalog_stratified.jsonl` (29.6K products stratified
+from 231K Amazebay catalog — 5 products per product type across 6000 categories).
+
+### Fallback: HuggingFace Dataset
+
+If the real catalog is not found, loads from `thebajajra/Amazebay-catalog` on
+HuggingFace Hub (or a local Arrow dataset), limited to 5000 items. Builds a
+FAISS Flat index at startup (~30s on CPU).
+
+## Environment variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `REAL_CATALOG_PATH` | `data/real_catalog_index/catalog.jsonl` | Real catalog JSONL |
+| `REAL_INDEX_DIR` | `data/real_catalog_index` | Directory with index.faiss + ids.txt |
+| `CATALOG_PATH` | `data/amazebay-2M` | Fallback: HF dataset path |
+| `CATALOG_MAX_ITEMS` | `5000` | Fallback: products to load |
+| `EMBEDDING_MODEL` | `Alibaba-NLP/gte-modernbert-base` | Must match index embeddings |
+| `EMBEDDING_DEVICE` | `cpu` | Device for query encoding |

app.py

@@ -0,0 +1,798 @@
+"""
+ShopRLVE-GYM  ·  Cart Environment  ·  Interactive Demo
+
+Play as an AI shopping assistant. A persona-driven customer asks you
+to find and cart products. Use catalog/cart tools, chat, then submit
+your answer to see the verifiable reward breakdown.
+
+Data requirements:
+  - Catalog: loaded from HuggingFace (thebajajra/Amazebay-catalog) or
+    local Arrow dataset (set CATALOG_PATH env var).
+  - FAISS index: built at startup from the loaded subset (~30s on CPU),
+    or loaded from disk if FAISS_INDEX_DIR is set and exists.
+  - Policies: policies.json bundled with the space.
+"""
+
+import json
+import logging
+import os
+import sys
+import time
+from pathlib import Path
+
+import gradio as gr
+import numpy as np
+
+# ---------------------------------------------------------------------------
+# Path setup — find src/shop_rlve relative to this file
+# ---------------------------------------------------------------------------
+_app_dir = Path(__file__).resolve().parent
+if (_app_dir / "src" / "shop_rlve").is_dir():
+    ROOT = _app_dir
+else:
+    ROOT = _app_dir.parent
+    if not (ROOT / "src" / "shop_rlve").is_dir():
+        ROOT = ROOT.parent  # two levels up
+sys.path.insert(0, str(ROOT / "src"))
+
+from shop_rlve.data.catalog_loader import load_catalog, load_real_catalog
+from shop_rlve.server.openenv import ShopRLVEEnv
+from shop_rlve.simulator.persona import PersonaWeights
+
+logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
+logger = logging.getLogger("shoprlve-space")
+
+# ---------------------------------------------------------------------------
+# Configuration (override via env vars on HF Spaces)
+# ---------------------------------------------------------------------------
+# Real catalog: 29.6K stratified products from Amazebay with gte-modernbert embeddings
+REAL_CATALOG_PATH = os.getenv(
+    "REAL_CATALOG_PATH",
+    str(ROOT / "data" / "real_catalog_index" / "catalog.jsonl"),
+)
+REAL_INDEX_DIR = os.getenv(
+    "REAL_INDEX_DIR",
+    str(ROOT / "data" / "real_catalog_index"),
+)
+# Fallback: original HF dataset (used if real catalog JSONL not found)
+CATALOG_PATH = os.getenv("CATALOG_PATH", str(ROOT / "data" / "amazebay-2M"))
+CATALOG_MAX_ITEMS = int(os.getenv("CATALOG_MAX_ITEMS", "5000"))
+# Embedding model must match the index — gte-modernbert for real catalog
+EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL", "Alibaba-NLP/gte-modernbert-base")
+EMBEDDING_DEVICE = os.getenv("EMBEDDING_DEVICE", "cpu")
+
+# ---------------------------------------------------------------------------
+# Global singleton
+# ---------------------------------------------------------------------------
+_env_singleton = None
+
+
+def _get_env() -> ShopRLVEEnv:
+    global _env_singleton
+    if _env_singleton is not None:
+        return _env_singleton
+
+    # Prefer real catalog (29.6K stratified products with pre-built FAISS index)
+    real_jsonl = Path(REAL_CATALOG_PATH)
+    real_index = Path(REAL_INDEX_DIR)
+    use_real = real_jsonl.is_file() and (real_index / "index.faiss").is_file()
+
+    if use_real:
+        logger.info("Loading real catalog from %s …", REAL_CATALOG_PATH)
+        products, variants = load_real_catalog(str(real_jsonl), seed=42)
+        logger.info("Loaded %d products, %d variants", len(products), len(variants))
+        faiss_path = str(real_index)
+    else:
+        logger.info(
+            "Real catalog not found at %s — falling back to HF dataset", REAL_CATALOG_PATH
+        )
+        products = load_catalog(CATALOG_PATH, max_items=CATALOG_MAX_ITEMS, seed=42)
+        variants = []
+        logger.info("Loaded %d products from HF dataset", len(products))
+        faiss_path = None
+
+    config = {
+        "embedding_model": EMBEDDING_MODEL,
+        "embedding_debug": False,
+        "embedding_device": EMBEDDING_DEVICE,
+    }
+    if faiss_path:
+        config["faiss_index_path"] = faiss_path
+
+    env = ShopRLVEEnv(
+        collection="C1",  # force CART only
+        catalog=(products, variants),
+        config=config,
+        seed=int(time.time()) % 100_000,
+    )
+    _env_singleton = env
+    logger.info("Environment ready! (real_catalog=%s)", use_real)
+    return env
+
+
+# ---------------------------------------------------------------------------
+# Tool definitions — CART-relevant subset
+# ---------------------------------------------------------------------------
+TOOLS: dict[str, dict] = {
+    "catalog.search": {
+        "icon": "search",
+        "description": "Search products by query and optional filters",
+        "args": {
+            "query":   {"type": "str",  "required": True,  "description": "Search query"},
+            "top_k":   {"type": "int",  "required": False, "default": 20,
+                        "description": "Number of results (1-500)"},
+            "filters": {"type": "json", "required": False, "default": None,
+                        "description": 'Filters JSON e.g. {"price_max":50}'},
+        },
+    },
+    "catalog.rerank": {
+        "icon": "sort",
+        "description": "Re-rank candidates by query relevance",
+        "args": {
+            "query":                 {"type": "str",  "required": True,
+                                      "description": "Reranking query"},
+            "candidate_product_ids": {"type": "list", "required": True,
+                                      "description": "Comma-separated product IDs"},
+            "top_k":                 {"type": "int",  "required": False, "default": 10,
+                                      "description": "Results to return"},
+        },
+    },
+    "catalog.get_product": {
+        "icon": "package",
+        "description": "Get full product details by ID",
+        "args": {"product_id": {"type": "str", "required": True,
+                                "description": "Product ID"}},
+    },
+    "catalog.get_variants": {
+        "icon": "layers",
+        "description": "Get colour/size variants for a product",
+        "args": {"product_id": {"type": "str", "required": True,
+                                "description": "Product ID"}},
+    },
+    "cart.view": {
+        "icon": "shopping-cart",
+        "description": "View current cart contents",
+        "args": {},
+    },
+    "cart.add": {
+        "icon": "plus-circle",
+        "description": "Add product to cart",
+        "args": {
+            "product_id": {"type": "str", "required": True,
+                           "description": "Product ID"},
+            "variant_id": {"type": "str", "required": False, "default": None,
+                           "description": "Variant ID (if specific variant needed)"},
+            "quantity":   {"type": "int", "required": False, "default": 1,
+                           "description": "Quantity"},
+        },
+    },
+    "cart.remove": {
+        "icon": "trash-2",
+        "description": "Remove a cart line",
+        "args": {"line_id": {"type": "str", "required": True,
+                              "description": "Cart line ID"}},
+    },
+    "cart.set_quantity": {
+        "icon": "edit-3",
+        "description": "Set quantity for a cart line",
+        "args": {
+            "line_id":  {"type": "str", "required": True,
+                         "description": "Cart line ID"},
+            "quantity": {"type": "int", "required": True,
+                         "description": "New quantity (0 = remove)"},
+        },
+    },
+    "user.get_visit_history": {
+        "icon": "clock",
+        "description": "Get customer's recently viewed products",
+        "args": {},
+    },
+    "datetime.now": {
+        "icon": "calendar",
+        "description": "Get current date and time",
+        "args": {},
+    },
+}
+
+
+# ---------------------------------------------------------------------------
+# Session state
+# ---------------------------------------------------------------------------
+class SessionState:
+    def __init__(self):
+        self.env: ShopRLVEEnv | None = None
+        self.obs = None
+        self.done = False
+        self.reward = 0.0
+        self.conversation: list[dict] = []
+        self.tool_history: list[str] = []
+        self.turn = 0
+        self.difficulty: int = 3
+        self.persona_weights: PersonaWeights | None = None
+        self.goal_params: dict = {}
+        self.episode_info: dict = {}
+        self.hidden_goal_md: str = ""
+        self.initial_msg_source: str = "unknown"
+        self.user_sim_log: list[str] = []
+
+
+# ---------------------------------------------------------------------------
+# CSS theme
+# ---------------------------------------------------------------------------
+CUSTOM_CSS = """
+/* Global */
+.gradio-container { max-width: 1440px !important; }
+
+/* Reward banner */
+.reward-banner {
+    border-radius: 16px; padding: 28px 24px; margin: 8px 0;
+    text-align: center; backdrop-filter: blur(8px);
+    border: 2px solid; transition: all 0.3s ease;
+}
+.reward-score { font-size: 52px; font-weight: 800; letter-spacing: -2px; }
+.reward-label { font-size: 18px; margin: 4px 0 12px; font-weight: 600; }
+.reward-grid {
+    display: flex; justify-content: center; gap: 36px;
+    flex-wrap: wrap; margin-top: 8px;
+}
+.reward-cell-label { font-size: 11px; text-transform: uppercase;
+                     letter-spacing: 1px; opacity: 0.6; }
+.reward-cell-value { font-size: 26px; font-weight: 700; }
+
+/* Goal panel */
+.goal-panel { font-size: 13px; line-height: 1.6; }
+.goal-panel table { width: 100%; }
+.goal-panel th, .goal-panel td { padding: 4px 8px; }
+
+/* Episode sidebar */
+.episode-stat { font-variant-numeric: tabular-nums; }
+
+/* Tool output */
+.tool-output { font-size: 13px; }
+.tool-output pre { max-height: 300px; overflow-y: auto; }
+
+/* Chat */
+.chat-area { min-height: 400px; }
+
+/* Persona bars */
+.persona-bar { font-family: monospace; font-size: 13px; line-height: 1.8; }
+
+/* Tool arg labels */
+.tool-arg-label { font-size: 12px; font-weight: 600; }
+"""
+
+
+# ---------------------------------------------------------------------------
+# Formatting helpers
+# ---------------------------------------------------------------------------
+
+def _fmt_tool_result(result: dict) -> str:
+    name = result.get("name", "?")
+    error = result.get("error")
+    data = result.get("result")
+    ms = result.get("duration_ms", 0)
+
+    if error:
+        return f"**{name}** `{ms:.0f}ms` — Error: {error}"
+
+    if name == "datetime.now" and isinstance(data, dict):
+        return (f"**{name}** `{ms:.0f}ms`\n"
+                f"> {data.get('date','?')} ({data.get('day_of_week','?')}) "
+                f"{data.get('time','?')}")
+
+    if isinstance(data, list):
+        lines = [f"**{name}** `{ms:.0f}ms` — {len(data)} results"]
+        for i, item in enumerate(data[:15]):
+            if isinstance(item, dict):
+                title = item.get("title", item.get("product_title", "?"))[:60]
+                pid = item.get("product_id", item.get("id", "?"))
+                price = item.get("price", item.get("unit_price", ""))
+                rating = item.get("rating", "")
+                qty = item.get("qty", "")
+                parts = [f"`{i+1}.` **{title}**"]
+                if price:
+                    parts.append(f"${price}")
+                if rating:
+                    parts.append(f"{rating}")
+                if qty:
+                    parts.append(f"x{qty}")
+                parts.append(f"`{pid}`")
+                lines.append("  " + " · ".join(parts))
+        if len(data) > 15:
+            lines.append(f"  *… +{len(data)-15} more*")
+        return "\n".join(lines)
+
+    if isinstance(data, dict):
+        return (f"**{name}** `{ms:.0f}ms`\n"
+                f"```json\n{json.dumps(data, indent=2, default=str)[:1200]}\n```")
+
+    return f"**{name}** `{ms:.0f}ms` — {str(data)[:400]}"
+
+
+def _fmt_reward_banner(reward: float, info: dict) -> str:
+    rb = info.get("reward_breakdown", {}) or {}
+    is_correct = rb.get("is_correct", False)
+    r_task = rb.get("r_task", 0)
+    r_eff = rb.get("r_eff", 0)
+    r_hall = rb.get("r_hall", 0)
+    fmt_ok = rb.get("format_valid", True)
+    tool_ok = rb.get("tool_valid", True)
+
+    if reward >= 0.8:
+        bg, border, fg = "#0d9488", "#14b8a6", "#f0fdfa"  # teal
+        label = "EXCELLENT"
+    elif reward >= 0.5:
+        bg, border, fg = "#059669", "#10b981", "#ecfdf5"  # emerald
+        label = "GOOD"
+    elif reward >= 0.2:
+        bg, border, fg = "#d97706", "#f59e0b", "#fffbeb"  # amber
+        label = "FAIR"
+    elif reward >= 0:
+        bg, border, fg = "#ea580c", "#f97316", "#fff7ed"  # orange
+        label = "POOR"
+    else:
+        bg, border, fg = "#dc2626", "#ef4444", "#fef2f2"  # red
+        label = "FAILED"
+
+    correct_html = (
+        '<span style="color:#10b981;">CORRECT</span>' if is_correct
+        else '<span style="color:#ef4444;">INCORRECT</span>'
+    )
+
+    html = f"""
+<div class="reward-banner" style="background:linear-gradient(145deg,{bg}18,{bg}30);
+     border-color:{border};">
+  <div class="reward-score" style="color:{border};">{reward:+.4f}</div>
+  <div class="reward-label" style="color:{border};">{label} &middot; {correct_html}</div>
+  <hr style="border-color:{border}30;margin:14px 0;">
+  <div class="reward-grid">
+    <div>
+      <div class="reward-cell-label" style="color:{fg}99;">r_task (75%)</div>
+      <div class="reward-cell-value" style="color:{border};">{r_task:+.4f}</div>
+    </div>
+    <div>
+      <div class="reward-cell-label" style="color:{fg}99;">r_eff (15%)</div>
+      <div class="reward-cell-value" style="color:{border};">{r_eff:+.4f}</div>
+    </div>
+    <div>
+      <div class="reward-cell-label" style="color:{fg}99;">r_hall (10%)</div>
+      <div class="reward-cell-value" style="color:{border};">{r_hall:+.4f}</div>
+    </div>
+  </div>
+  <div style="margin-top:14px;font-size:12px;opacity:0.5;">
+    Format {'Pass' if fmt_ok else 'Fail'} &middot;
+    Tools {'Pass' if tool_ok else 'Fail'}
+  </div>
+</div>"""
+
+    details = rb.get("details", {})
+    if details:
+        html += "\n\n| Metric | Value |\n|--------|-------|\n"
+        for k, v in details.items():
+            html += f"| {k} | {v:.4f if isinstance(v, float) else v} |\n"
+    return html
+
+
+def _fmt_hidden_goal(ep_state) -> str:
+    if not ep_state or not ep_state.hidden_goal:
+        return "*Reset to generate a goal.*"
+    problem = ep_state.hidden_goal
+    extra = problem.extra or {}
+
+    lines = ["#### Target Cart"]
+    items = extra.get("item_details", [])
+    visit = extra.get("visit_history", [])
+
+    if items:
+        lines += ["", "| # | Product | Qty | Variant | ID |",
+                      "|--:|---------|----:|---------|:---|"]
+        for i, d in enumerate(items, 1):
+            desc_parts = d.get("description", [])
+            desc_str = ", ".join(str(p) for p in desc_parts[:3]) if desc_parts else "—"
+            variant = d.get("variant_desc", "—")
+            lines.append(
+                f"| {i} | {desc_str[:45]} | {d.get('qty', 1)} "
+                f"| {variant} | `{d.get('product_id', '?')}` |"
+            )
+        lines.append("")
+        lines.append("**Hidden titles:**")
+        for i, d in enumerate(items, 1):
+            lines.append(f"{i}. {d.get('title', '?')[:65]}")
+    else:
+        lines.append("*No item details available.*")
+
+    if visit:
+        n_dist = max(0, len(visit) - len(items))
+        lines.append(f"\n**Visit history:** {len(visit)} items "
+                     f"({len(items)} targets + {n_dist} distractors)")
+
+    return "\n".join(lines)
+
+
+def _fmt_episode(session: SessionState) -> str:
+    ep = session.env.get_episode_state() if session.env else None
+    extra = ep.hidden_goal.extra if ep and ep.hidden_goal else {}
+    t_max = extra.get("T_max", 14)
+    p_miss = extra.get("p_missing", 0)
+    p_noise = extra.get("p_noise", 0)
+    n_cart = len(ep.cart.lines) if ep else 0
+    n_seen = len(ep.seen_product_ids) if ep else 0
+    status = "Done" if session.done else "Active"
+
+    return f"""| | |
+|---|---|
+| **Difficulty** | {session.difficulty} / 10 |
+| **Turn** | {session.turn} / {t_max} |
+| **Status** | {status} |
+| **Cart lines** | {n_cart} |
+| **Seen products** | {n_seen} |
+| **Tool calls** | {len(session.tool_history)} |
+| **p_missing** | {p_miss:.2f} |
+| **p_noise** | {p_noise:.3f} |"""
+
+
+def _fmt_chat(session: SessionState) -> list[dict]:
+    out = []
+    for m in session.conversation:
+        role = m.get("role", "user")
+        content = m.get("content", "")
+        out.append({"role": "user" if role == "user" else "assistant",
+                     "content": content})
+    return out
+
+
+def _fmt_persona(w: PersonaWeights | None) -> str:
+    if w is None:
+        return "*Click Reset to start.*"
+    dims = [
+        ("Price", w.w_price),
+        ("Rating", w.w_rating),
+        ("Shipping", w.w_ship),
+        ("Brand", w.w_brand),
+        ("Similarity", w.w_similarity),
+    ]
+    lines = []
+    for label, val in dims:
+        filled = int(val * 20)
+        bar = "█" * filled + "░" * (20 - filled)
+        lines.append(f"**{label:>10}** `{bar}` {val:.2f}")
+    return "\n".join(lines)
+
+
+def _fmt_verbalization(session: SessionState) -> str:
+    src = session.initial_msg_source
+    src_label = {"llm": "LLM (Ollama)", "template": "Template"}.get(src, "—")
+    lines = [f"**Initial message:** {src_label}", ""]
+    if session.user_sim_log:
+        lines.append("**Response log:**")
+        for entry in session.user_sim_log[-10:]:
+            lines.append(f"- {entry}")
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Core actions
+# ---------------------------------------------------------------------------
+
+def reset_episode(state, sel_diff):
+    env = _get_env()
+    s = SessionState()
+    s.env = env
+    diff = int(sel_diff)
+    s.difficulty = diff
+
+    obs = env.reset(env_id="CART", difficulty=diff)
+    s.obs, s.turn, s.conversation = obs, obs.turn, list(obs.conversation)
+
+    ep = env.get_episode_state()
+    if ep:
+        s.persona_weights = ep.persona_weights
+        s.goal_params = env._extract_goal_params(ep.hidden_goal, ep.env_id)
+        s.hidden_goal_md = _fmt_hidden_goal(ep)
+        s.initial_msg_source = "llm"
+        s.user_sim_log.append(f"Initial: LLM verbalization")
+
+    return (
+        s,                          # state
+        _fmt_chat(s),               # chatbot
+        _fmt_persona(s.persona_weights),  # persona_md
+        _fmt_episode(s),            # episode_md
+        "",                         # reward_display
+        s.hidden_goal_md,           # goal_md
+        _fmt_verbalization(s),      # verb_md
+        "",                         # tool_out
+        gr.update(interactive=True),   # exec_btn
+        gr.update(interactive=True),   # asst_in
+        gr.update(interactive=True),   # send_btn
+        gr.update(interactive=True),   # done_btn
+    )
+
+
+def execute_tool(state, tool_name, a1, a2, a3, a4, a5):
+    if state is None or state.done:
+        return state, [], "Reset first.", "", "", "", "", ""
+    env = state.env or _get_env()
+
+    # Parse args from the UI textboxes
+    args = {}
+    tdef = TOOLS.get(tool_name, {})
+    adefs = tdef.get("args", {})
+    vals = [a1, a2, a3, a4, a5]
+    for (aname, adef), v in zip(adefs.items(), vals):
+        if v is None or v == "":
+            if adef.get("required"):
+                return (state, _fmt_chat(state),
+                        f"Required argument: `{aname}`", _fmt_episode(state),
+                        "", state.hidden_goal_md, _fmt_verbalization(state), "")
+            continue
+        t = adef.get("type", "str")
+        if t == "int":
+            try:
+                args[aname] = int(v)
+            except ValueError:
+                args[aname] = adef.get("default", 10)
+        elif t == "json":
+            try:
+                args[aname] = json.loads(v) if v else None
+            except json.JSONDecodeError:
+                args[aname] = None
+        elif t == "list":
+            args[aname] = [x.strip() for x in v.split(",") if x.strip()]
+        else:
+            args[aname] = str(v)
+
+    action = json.dumps({
+        "assistant_message": f"[tool: {tool_name}]",
+        "tool_calls": [{"name": tool_name, "args": args}],
+    })
+    obs, reward, done, info = env.step(action)
+    state.obs, state.turn, state.done = obs, obs.turn, done
+    state.reward, state.conversation = reward, list(obs.conversation)
+    state.episode_info = info
+
+    if not done and obs.conversation and obs.conversation[-1].get("role") == "user":
+        state.user_sim_log.append(f"T{state.turn}: LLM response")
+
+    tout = ""
+    if obs.tool_results:
+        for tr in obs.tool_results:
+            tout += _fmt_tool_result(tr) + "\n\n"
+        state.tool_history.append(tool_name)
+
+    rmd = _fmt_reward_banner(reward, info) if done else ""
+    return (state, _fmt_chat(state), tout or "No output.",
+            _fmt_episode(state), rmd, state.hidden_goal_md,
+            _fmt_verbalization(state), "")
+
+
+def submit_response(state, msg):
+    if state is None or state.done:
+        return state, [], "", "", "", "", "", ""
+    if not msg.strip():
+        return (state, _fmt_chat(state), "Write a message first.",
+                _fmt_episode(state), "", state.hidden_goal_md,
+                _fmt_verbalization(state), "")
+
+    env = state.env or _get_env()
+    action = json.dumps({"assistant_message": msg, "tool_calls": []})
+    obs, reward, done, info = env.step(action)
+    state.obs, state.turn, state.done = obs, obs.turn, done
+    state.reward, state.conversation = reward, list(obs.conversation)
+    state.episode_info = info
+
+    if not done and obs.conversation and obs.conversation[-1].get("role") == "user":
+        state.user_sim_log.append(f"T{state.turn}: LLM response")
+
+    rmd = _fmt_reward_banner(reward, info) if done else ""
+    return (state, _fmt_chat(state), "", _fmt_episode(state),
+            rmd, state.hidden_goal_md, _fmt_verbalization(state), "")
+
+
+def submit_answer(state, msg, pids):
+    if state is None or state.done:
+        return state, [], "", "", "Episode already ended.", "", "", ""
+
+    env = state.env or _get_env()
+    ids = [x.strip() for x in pids.split(",") if x.strip()] if pids else []
+
+    answer = {"env": "CART", "done": True, "recommended_product_ids": ids}
+    action = json.dumps({
+        "assistant_message": msg or "Here is my final cart.",
+        "tool_calls": [],
+        "answer": answer,
+    })
+    obs, reward, done, info = env.step(action)
+    state.obs, state.turn, state.done = obs, obs.turn, done
+    state.reward, state.conversation = reward, list(obs.conversation)
+    state.episode_info = info
+
+    return (state, _fmt_chat(state), "", _fmt_episode(state),
+            _fmt_reward_banner(reward, info), state.hidden_goal_md,
+            _fmt_verbalization(state), "")
+
+
+def update_tool_args(tool_name):
+    tdef = TOOLS.get(tool_name, {})
+    adefs = tdef.get("args", {})
+    names = list(adefs.keys())
+    updates = []
+    for i in range(5):
+        if i < len(names):
+            n = names[i]
+            d = adefs[n]
+            req = " *" if d.get("required") else f" (default: {d.get('default', '')})"
+            updates.append(gr.update(
+                label=f"{n}{req}", placeholder=d.get("description", ""),
+                value="", visible=True,
+            ))
+        else:
+            updates.append(gr.update(label=f"arg{i+1}", value="", visible=False))
+
+    # Build description markdown
+    dl = [f"**{tool_name}** — {tdef.get('description', '')}"]
+    if adefs:
+        for an, ad in adefs.items():
+            r = "required" if ad.get("required") else f"default={ad.get('default')}"
+            dl.append(f"- `{an}` ({r}) — {ad.get('description', '')}")
+    else:
+        dl.append("*No arguments — click Execute.*")
+    return (*updates, gr.update(value="\n".join(dl)))
+
+
+# ---------------------------------------------------------------------------
+# Gradio UI
+# ---------------------------------------------------------------------------
+
+HEADER_MD = """
+<div style="text-align:center;padding:12px 0 4px;">
+  <h1 style="font-size:28px;font-weight:800;margin:0;">
+    ShopRLVE-GYM · Cart Environment
+  </h1>
+  <p style="color:#6b7280;margin:4px 0 0;font-size:14px;">
+    You are the AI agent. A simulated customer asks for help building their cart.<br>
+    Use tools to search &amp; add products, chat with the customer, then submit your answer.
+  </p>
+</div>
+"""
+
+with gr.Blocks(
+    title="ShopRLVE Cart",
+    css=CUSTOM_CSS,
+    theme=gr.themes.Base(
+        primary_hue=gr.themes.colors.teal,
+        secondary_hue=gr.themes.colors.slate,
+        neutral_hue=gr.themes.colors.gray,
+        font=[gr.themes.GoogleFont("Inter"), "system-ui", "sans-serif"],
+        font_mono=[gr.themes.GoogleFont("JetBrains Mono"), "monospace"],
+    ),
+) as demo:
+    session_state = gr.State(value=None)
+    gr.HTML(HEADER_MD)
+
+    # ── Reward banner (full width, top) ──
+    reward_display = gr.HTML(value="")
+
+    with gr.Row(equal_height=False):
+        # ═════════��═════════════════════════
+        # LEFT SIDEBAR — Controls & Info
+        # ═══════════════════════════════════
+        with gr.Column(scale=1, min_width=280):
+            gr.Markdown("### Controls")
+            diff_sl = gr.Slider(
+                0, 10, step=1, value=3, label="Difficulty",
+                info="Higher = more items, variants, noise",
+            )
+            reset_btn = gr.Button(
+                "Reset Episode", variant="primary", size="lg",
+            )
+
+            gr.Markdown("### Episode")
+            episode_md = gr.Markdown("*Reset to start.*")
+
+            with gr.Accordion("Persona Weights", open=False):
+                persona_md = gr.Markdown("*Reset to start.*", elem_classes=["persona-bar"])
+
+            with gr.Accordion("Verbalization", open=False):
+                verb_md = gr.Markdown("")
+
+        # ═══════════════════════════════════
+        # CENTER — Chat + Answer
+        # ═══════════════════════════════════
+        with gr.Column(scale=2, min_width=460):
+            chatbot = gr.Chatbot(
+                [], height=440, type="messages",
+                placeholder="Reset an episode to begin the conversation.",
+                show_copy_button=True,
+                elem_classes=["chat-area"],
+            )
+
+            with gr.Row():
+                asst_in = gr.Textbox(
+                    label="Your message", lines=2, interactive=False,
+                    placeholder="Type your response to the customer…",
+                    scale=4,
+                )
+                send_btn = gr.Button("Send", interactive=False, scale=1)
+
+            with gr.Accordion("Submit Final Answer", open=False):
+                gr.Markdown(
+                    "*When the cart is ready, paste the product IDs you added "
+                    "and submit.*"
+                )
+                ans_pids = gr.Textbox(
+                    label="Product IDs in cart",
+                    placeholder="B01ABC, B02DEF, …",
+                    lines=1,
+                )
+                done_btn = gr.Button(
+                    "Submit Answer", variant="stop", interactive=False,
+                )
+
+        # ═══════════════════════════════════
+        # RIGHT SIDEBAR — Tools & Goal
+        # ═══════════════════════════════════
+        with gr.Column(scale=1, min_width=310):
+            gr.Markdown("### Tools")
+            tool_sel = gr.Dropdown(
+                list(TOOLS.keys()), value="catalog.search",
+                label="Select tool",
+            )
+            tool_desc = gr.Markdown("")
+            ta1 = gr.Textbox(label="arg1")
+            ta2 = gr.Textbox(label="arg2", visible=True)
+            ta3 = gr.Textbox(label="arg3", visible=True)
+            ta4 = gr.Textbox(label="arg4", visible=False)
+            ta5 = gr.Textbox(label="arg5", visible=False)
+            exec_btn = gr.Button("Execute", variant="secondary")
+
+            with gr.Accordion("Tool Output", open=True):
+                tool_out = gr.Markdown("", elem_classes=["tool-output"])
+
+            with gr.Accordion("Hidden Goal (ground truth)", open=True):
+                goal_md = gr.Markdown(
+                    "*Reset to generate a goal.*",
+                    elem_classes=["goal-panel"],
+                )
+
+    # ── Wiring ──
+    _out8 = [
+        session_state, chatbot, tool_out, episode_md,
+        reward_display, goal_md, verb_md, asst_in,
+    ]
+
+    reset_btn.click(
+        reset_episode, [session_state, diff_sl],
+        [session_state, chatbot, persona_md, episode_md,
+         reward_display, goal_md, verb_md, tool_out,
+         exec_btn, asst_in, send_btn, done_btn],
+    )
+
+    tool_sel.change(
+        update_tool_args, [tool_sel],
+        [ta1, ta2, ta3, ta4, ta5, tool_desc],
+    )
+
+    exec_btn.click(
+        execute_tool,
+        [session_state, tool_sel, ta1, ta2, ta3, ta4, ta5],
+        _out8,
+    )
+
+    send_btn.click(
+        submit_response, [session_state, asst_in], _out8,
+    ).then(lambda: "", outputs=[asst_in])
+
+    done_btn.click(
+        submit_answer,
+        [session_state, asst_in, ans_pids],
+        _out8,
+    )
+
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=int(os.getenv("GRADIO_SERVER_PORT", "7860")),
+        share=False,
+        show_error=True,
+    )

policies.json

@@ -0,0 +1,980 @@
+{
+  "policies": [
+    {
+      "rule_id": "pol_001",
+      "title": "Return window for electronics",
+      "category": "returns",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "electronics"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 15
+    },
+    {
+      "rule_id": "pol_002",
+      "title": "Return window for clothing",
+      "category": "returns",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "clothing"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 30
+    },
+    {
+      "rule_id": "pol_003",
+      "title": "Return window for furniture",
+      "category": "returns",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "furniture"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 30
+    },
+    {
+      "rule_id": "pol_004",
+      "title": "Return window for groceries",
+      "category": "returns",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "groceries"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 0
+    },
+    {
+      "rule_id": "pol_005",
+      "title": "Return window for jewelry",
+      "category": "returns",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "jewelry"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 30
+    },
+    {
+      "rule_id": "pol_006",
+      "title": "Return window for books",
+      "category": "returns",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "books"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 14
+    },
+    {
+      "rule_id": "pol_007",
+      "title": "Return window for toys",
+      "category": "returns",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "toys"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 30
+    },
+    {
+      "rule_id": "pol_008",
+      "title": "Return window for sports",
+      "category": "returns",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "sports"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 30
+    },
+    {
+      "rule_id": "pol_009",
+      "title": "Return window for beauty",
+      "category": "returns",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "beauty"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 14
+    },
+    {
+      "rule_id": "pol_010",
+      "title": "Return window for automotive",
+      "category": "returns",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "automotive"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 15
+    },
+    {
+      "rule_id": "pol_011",
+      "title": "Return fee for mail returns",
+      "category": "returns",
+      "conditions": [
+        {
+          "field": "return_method",
+          "op": "eq",
+          "value": "mail"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 5.99
+    },
+    {
+      "rule_id": "pol_012",
+      "title": "Return fee for in-store returns",
+      "category": "returns",
+      "conditions": [
+        {
+          "field": "return_method",
+          "op": "eq",
+          "value": "in_store"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 0.0
+    },
+    {
+      "rule_id": "pol_013",
+      "title": "Return fee for pickup returns",
+      "category": "returns",
+      "conditions": [
+        {
+          "field": "return_method",
+          "op": "eq",
+          "value": "pickup"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 0.0
+    },
+    {
+      "rule_id": "pol_014",
+      "title": "Free mail returns for premium members",
+      "category": "returns",
+      "conditions": [
+        {
+          "field": "return_method",
+          "op": "eq",
+          "value": "mail"
+        },
+        {
+          "field": "membership_tier",
+          "op": "eq",
+          "value": "premium"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 0.0
+    },
+    {
+      "rule_id": "pol_015",
+      "title": "Free shipping threshold for non-members",
+      "category": "shipping",
+      "conditions": [
+        {
+          "field": "membership_tier",
+          "op": "eq",
+          "value": "none"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 50.0
+    },
+    {
+      "rule_id": "pol_016",
+      "title": "Free shipping threshold for basic members",
+      "category": "shipping",
+      "conditions": [
+        {
+          "field": "membership_tier",
+          "op": "eq",
+          "value": "basic"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 35.0
+    },
+    {
+      "rule_id": "pol_017",
+      "title": "Free shipping threshold for premium members",
+      "category": "shipping",
+      "conditions": [
+        {
+          "field": "membership_tier",
+          "op": "eq",
+          "value": "premium"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 0.0
+    },
+    {
+      "rule_id": "pol_018",
+      "title": "Standard shipping cost",
+      "category": "shipping",
+      "conditions": [
+        {
+          "field": "shipping_method",
+          "op": "eq",
+          "value": "standard"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 7.99
+    },
+    {
+      "rule_id": "pol_019",
+      "title": "Express shipping cost",
+      "category": "shipping",
+      "conditions": [
+        {
+          "field": "shipping_method",
+          "op": "eq",
+          "value": "express"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 14.99
+    },
+    {
+      "rule_id": "pol_020",
+      "title": "Overnight shipping cost",
+      "category": "shipping",
+      "conditions": [
+        {
+          "field": "shipping_method",
+          "op": "eq",
+          "value": "overnight"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 24.99
+    },
+    {
+      "rule_id": "pol_021",
+      "title": "Standard shipping delivery time",
+      "category": "shipping",
+      "conditions": [
+        {
+          "field": "shipping_method",
+          "op": "eq",
+          "value": "standard"
+        }
+      ],
+      "answer_type": "categorical",
+      "answer": "5-7 business days"
+    },
+    {
+      "rule_id": "pol_022",
+      "title": "Express shipping delivery time",
+      "category": "shipping",
+      "conditions": [
+        {
+          "field": "shipping_method",
+          "op": "eq",
+          "value": "express"
+        }
+      ],
+      "answer_type": "categorical",
+      "answer": "2-3 business days"
+    },
+    {
+      "rule_id": "pol_023",
+      "title": "Overnight shipping delivery time",
+      "category": "shipping",
+      "conditions": [
+        {
+          "field": "shipping_method",
+          "op": "eq",
+          "value": "overnight"
+        }
+      ],
+      "answer_type": "categorical",
+      "answer": "Next business day"
+    },
+    {
+      "rule_id": "pol_024",
+      "title": "Free express shipping for premium members on orders over $100",
+      "category": "shipping",
+      "conditions": [
+        {
+          "field": "membership_tier",
+          "op": "eq",
+          "value": "premium"
+        },
+        {
+          "field": "order_total",
+          "op": "gte",
+          "value": 100.0
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 0.0
+    },
+    {
+      "rule_id": "pol_025",
+      "title": "Heavy item shipping surcharge for furniture over 50 lbs",
+      "category": "shipping",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "furniture"
+        },
+        {
+          "field": "weight_lbs",
+          "op": "gt",
+          "value": 50
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 29.99
+    },
+    {
+      "rule_id": "pol_026",
+      "title": "International standard shipping cost",
+      "category": "shipping",
+      "conditions": [
+        {
+          "field": "shipping_method",
+          "op": "eq",
+          "value": "standard"
+        },
+        {
+          "field": "destination",
+          "op": "eq",
+          "value": "international"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 19.99
+    },
+    {
+      "rule_id": "pol_027",
+      "title": "Alaska/Hawaii shipping surcharge",
+      "category": "shipping",
+      "conditions": [
+        {
+          "field": "destination",
+          "op": "in",
+          "value": [
+            "alaska",
+            "hawaii"
+          ]
+        },
+        {
+          "field": "shipping_method",
+          "op": "eq",
+          "value": "standard"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 9.99
+    },
+    {
+      "rule_id": "pol_028",
+      "title": "Price match window for in-store purchases",
+      "category": "pricing",
+      "conditions": [
+        {
+          "field": "purchase_channel",
+          "op": "eq",
+          "value": "in_store"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 14
+    },
+    {
+      "rule_id": "pol_029",
+      "title": "Price match window for online purchases",
+      "category": "pricing",
+      "conditions": [
+        {
+          "field": "purchase_channel",
+          "op": "eq",
+          "value": "online"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 7
+    },
+    {
+      "rule_id": "pol_030",
+      "title": "Price match eligible for electronics from authorized retailers",
+      "category": "pricing",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "electronics"
+        },
+        {
+          "field": "competitor_type",
+          "op": "eq",
+          "value": "authorized_retailer"
+        }
+      ],
+      "answer_type": "categorical",
+      "answer": "eligible"
+    },
+    {
+      "rule_id": "pol_031",
+      "title": "Price match ineligible for marketplace sellers",
+      "category": "pricing",
+      "conditions": [
+        {
+          "field": "competitor_type",
+          "op": "eq",
+          "value": "marketplace"
+        },
+        {
+          "field": "cat",
+          "op": "neq",
+          "value": "electronics"
+        }
+      ],
+      "answer_type": "categorical",
+      "answer": "ineligible"
+    },
+    {
+      "rule_id": "pol_032",
+      "title": "5% bulk discount for 10+ identical items",
+      "category": "pricing",
+      "conditions": [
+        {
+          "field": "quantity",
+          "op": "gte",
+          "value": 10
+        },
+        {
+          "field": "quantity",
+          "op": "lt",
+          "value": 25
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 5
+    },
+    {
+      "rule_id": "pol_033",
+      "title": "10% bulk discount for 25+ identical items",
+      "category": "pricing",
+      "conditions": [
+        {
+          "field": "quantity",
+          "op": "gte",
+          "value": 25
+        },
+        {
+          "field": "quantity",
+          "op": "lt",
+          "value": 100
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 10
+    },
+    {
+      "rule_id": "pol_034",
+      "title": "15% bulk discount for 100+ identical items",
+      "category": "pricing",
+      "conditions": [
+        {
+          "field": "quantity",
+          "op": "gte",
+          "value": 100
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 15
+    },
+    {
+      "rule_id": "pol_035",
+      "title": "Maximum coupons per order",
+      "category": "pricing",
+      "conditions": [
+        {
+          "field": "order_type",
+          "op": "eq",
+          "value": "standard"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 2
+    },
+    {
+      "rule_id": "pol_036",
+      "title": "Coupons not applicable on clearance items",
+      "category": "pricing",
+      "conditions": [
+        {
+          "field": "item_status",
+          "op": "eq",
+          "value": "clearance"
+        },
+        {
+          "field": "coupon_type",
+          "op": "eq",
+          "value": "percentage"
+        }
+      ],
+      "answer_type": "categorical",
+      "answer": "not_applicable"
+    },
+    {
+      "rule_id": "pol_037",
+      "title": "Student discount on electronics",
+      "category": "pricing",
+      "conditions": [
+        {
+          "field": "customer_type",
+          "op": "eq",
+          "value": "student"
+        },
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "electronics"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 10
+    },
+    {
+      "rule_id": "pol_038",
+      "title": "Employee discount percentage",
+      "category": "pricing",
+      "conditions": [
+        {
+          "field": "customer_type",
+          "op": "eq",
+          "value": "employee"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 20
+    },
+    {
+      "rule_id": "pol_039",
+      "title": "Open-box item discount",
+      "category": "pricing",
+      "conditions": [
+        {
+          "field": "item_condition",
+          "op": "eq",
+          "value": "open_box"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 15
+    },
+    {
+      "rule_id": "pol_040",
+      "title": "Basic membership annual fee",
+      "category": "membership",
+      "conditions": [
+        {
+          "field": "membership_tier",
+          "op": "eq",
+          "value": "basic"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 29.99
+    },
+    {
+      "rule_id": "pol_041",
+      "title": "Premium membership annual fee",
+      "category": "membership",
+      "conditions": [
+        {
+          "field": "membership_tier",
+          "op": "eq",
+          "value": "premium"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 99.99
+    },
+    {
+      "rule_id": "pol_042",
+      "title": "Basic member points per dollar spent",
+      "category": "membership",
+      "conditions": [
+        {
+          "field": "membership_tier",
+          "op": "eq",
+          "value": "basic"
+        },
+        {
+          "field": "purchase_channel",
+          "op": "eq",
+          "value": "online"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 1
+    },
+    {
+      "rule_id": "pol_043",
+      "title": "Premium member points per dollar spent",
+      "category": "membership",
+      "conditions": [
+        {
+          "field": "membership_tier",
+          "op": "eq",
+          "value": "premium"
+        },
+        {
+          "field": "purchase_channel",
+          "op": "eq",
+          "value": "online"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 3
+    },
+    {
+      "rule_id": "pol_044",
+      "title": "Premium member free returns",
+      "category": "membership",
+      "conditions": [
+        {
+          "field": "membership_tier",
+          "op": "eq",
+          "value": "premium"
+        }
+      ],
+      "answer_type": "categorical",
+      "answer": "Free returns on all items via any method"
+    },
+    {
+      "rule_id": "pol_045",
+      "title": "Premium member priority shipping",
+      "category": "membership",
+      "conditions": [
+        {
+          "field": "membership_tier",
+          "op": "eq",
+          "value": "premium"
+        }
+      ],
+      "answer_type": "categorical",
+      "answer": "Free 2-day shipping on all orders"
+    },
+    {
+      "rule_id": "pol_046",
+      "title": "Basic to premium upgrade spending requirement",
+      "category": "membership",
+      "conditions": [
+        {
+          "field": "membership_tier",
+          "op": "eq",
+          "value": "basic"
+        },
+        {
+          "field": "annual_spend",
+          "op": "gte",
+          "value": 500
+        }
+      ],
+      "answer_type": "categorical",
+      "answer": "Eligible for complimentary premium upgrade"
+    },
+    {
+      "rule_id": "pol_047",
+      "title": "Membership cancellation refund policy",
+      "category": "membership",
+      "conditions": [
+        {
+          "field": "days_since_signup",
+          "op": "lte",
+          "value": 30
+        }
+      ],
+      "answer_type": "categorical",
+      "answer": "Full refund within 30 days of signup"
+    },
+    {
+      "rule_id": "pol_048",
+      "title": "Guest checkout order limit",
+      "category": "membership",
+      "conditions": [
+        {
+          "field": "membership_tier",
+          "op": "eq",
+          "value": "none"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 500.0
+    },
+    {
+      "rule_id": "pol_049",
+      "title": "Premium member birthday bonus points",
+      "category": "membership",
+      "conditions": [
+        {
+          "field": "membership_tier",
+          "op": "eq",
+          "value": "premium"
+        },
+        {
+          "field": "is_birthday_month",
+          "op": "eq",
+          "value": true
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 500
+    },
+    {
+      "rule_id": "pol_050",
+      "title": "Standard warranty for electronics",
+      "category": "warranty",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "electronics"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 12
+    },
+    {
+      "rule_id": "pol_051",
+      "title": "Standard warranty for furniture",
+      "category": "warranty",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "furniture"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 24
+    },
+    {
+      "rule_id": "pol_052",
+      "title": "Standard warranty for appliances",
+      "category": "warranty",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "appliances"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 12
+    },
+    {
+      "rule_id": "pol_053",
+      "title": "Standard warranty for clothing",
+      "category": "warranty",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "clothing"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 3
+    },
+    {
+      "rule_id": "pol_054",
+      "title": "Standard warranty for jewelry",
+      "category": "warranty",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "jewelry"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 6
+    },
+    {
+      "rule_id": "pol_055",
+      "title": "Standard warranty for toys",
+      "category": "warranty",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "toys"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 6
+    },
+    {
+      "rule_id": "pol_056",
+      "title": "Standard warranty for sports",
+      "category": "warranty",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "sports"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 6
+    },
+    {
+      "rule_id": "pol_057",
+      "title": "Standard warranty for automotive",
+      "category": "warranty",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "automotive"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 12
+    },
+    {
+      "rule_id": "pol_058",
+      "title": "Extended warranty cost for electronics under $200",
+      "category": "warranty",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "electronics"
+        },
+        {
+          "field": "price",
+          "op": "lt",
+          "value": 200
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 19.99
+    },
+    {
+      "rule_id": "pol_059",
+      "title": "Extended warranty cost for electronics $200-$500",
+      "category": "warranty",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "electronics"
+        },
+        {
+          "field": "price",
+          "op": "gte",
+          "value": 200
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 49.99
+    },
+    {
+      "rule_id": "pol_060",
+      "title": "Extended warranty cost for furniture over $500",
+      "category": "warranty",
+      "conditions": [
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "furniture"
+        },
+        {
+          "field": "price",
+          "op": "gte",
+          "value": 500
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 79.99
+    },
+    {
+      "rule_id": "pol_061",
+      "title": "Premium member bonus warranty months for electronics",
+      "category": "warranty",
+      "conditions": [
+        {
+          "field": "membership_tier",
+          "op": "eq",
+          "value": "premium"
+        },
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "electronics"
+        }
+      ],
+      "answer_type": "numeric",
+      "answer": 6
+    },
+    {
+      "rule_id": "pol_062",
+      "title": "Accidental damage protection for premium members on electronics over $100",
+      "category": "warranty",
+      "conditions": [
+        {
+          "field": "membership_tier",
+          "op": "eq",
+          "value": "premium"
+        },
+        {
+          "field": "cat",
+          "op": "eq",
+          "value": "electronics"
+        },
+        {
+          "field": "price",
+          "op": "gte",
+          "value": 100
+        }
+      ],
+      "answer_type": "categorical",
+      "answer": "Included free for 12 months"
+    }
+  ]
+}

requirements.txt

@@ -0,0 +1,9 @@
+gradio>=5.0.0
+huggingface_hub>=0.26.0
+sentence-transformers>=3.0.0
+faiss-cpu>=1.7.0
+datasets>=2.0.0
+numpy>=1.24.0
+pydantic>=2.0.0
+torch>=2.0.0
+transformers>=4.40.0