Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,81 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Multi-stage build using openenv-base
+# This Dockerfile is flexible and works for both:
+# - In-repo environments (with local OpenEnv sources)
+# - Standalone environments (with openenv from PyPI/Git)
+# The build script (openenv build) handles context detection and sets appropriate build args.
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app
+
+# Ensure git is available (required for installing dependencies from VCS)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git && \
+    rm -rf /var/lib/apt/lists/*
+
+# Build argument to control whether we're building standalone or in-repo
+ARG BUILD_MODE=in-repo
+ARG ENV_NAME=recruitopenenv
+
+# Copy environment code (always at root of build context)
+COPY . /app/env
+
+# For in-repo builds, openenv is already vendored in the build context
+# For standalone builds, openenv will be installed via pyproject.toml
+WORKDIR /app/env
+
+# Ensure uv is available (for local builds where base image lacks it)
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh && \
+        mv /root/.local/bin/uv /usr/local/bin/uv && \
+        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
+    fi
+    
+# Install dependencies using uv sync
+# If uv.lock exists, use it; otherwise resolve on the fly
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-install-project --no-editable; \
+    else \
+        uv sync --no-install-project --no-editable; \
+    fi
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-editable; \
+    else \
+        uv sync --no-editable; \
+    fi
+
+# Final runtime stage
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+# Copy the virtual environment from builder
+COPY --from=builder /app/env/.venv /app/.venv
+
+# Copy the environment code
+COPY --from=builder /app/env /app/env
+
+# Set PATH to use the virtual environment
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Set PYTHONPATH so imports work correctly
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the FastAPI server
+# The module path is constructed to work with the /app/env structure
+ENV ENABLE_WEB_INTERFACE=true
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

README.md

@@ -1,10 +1,123 @@
 ---
-title: Recruitopenenv
-emoji: 🏢
-colorFrom: gray
-colorTo: yellow
+title: Driver Recruit Environment
+emoji: 🚛
+colorFrom: blue
+colorTo: green
 sdk: docker
 pinned: false
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
+  - reinforcement-learning
+  - recruiting
+  - multi-turn
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🚛 Driver Recruit Environment
+
+A **multi-turn, tool-based RL environment** for training LLMs to recruit truck drivers through a CRM system. Built on [OpenEnv 0.2.1](https://github.com/meta-pytorch/OpenEnv).
+
+The agent must discover driver qualifications through conversation, record info in the CRM, get management approval, and hire — all using structured tool calls across 15-40+ step episodes.
+
+## Pipeline
+
+```
+lead → contacted → interested → approval_pending → offer_sent → hired
+```
+
+## Tools
+
+| Tool | Actions | Purpose |
+|------|---------|---------|
+| **crm** | `read_candidate`, `update_stage`, `update_field`, `add_note` | Manage pipeline & record info |
+| **messaging** | `send_message`, `read_reply` | Screen driver (18 topics) |
+| **approval** | `request_approval`, `check_approval` | Get management sign-off |
+| **workflow** | `wait` | Advance time for approval processing |
+
+## Reward Signal
+
+- **Successful hire** (good job fit): **+10** to **+15** (base + CRM bonus)
+- **Bad hire** (poor match): **-5**
+- **Ghosted** (trust runs out): **-4**
+- **Per-step**: Small rewards/penalties for correct/incorrect actions
+
+## What Makes This Hard
+
+- **Long horizon**: 15-40+ tool calls per episode
+- **Information gathering**: Must ask the right screening questions to match driver to the right job
+- **Trust dynamics**: Each message costs trust — ask too many questions and the driver ghosts
+- **Job matching**: 6 jobs per episode (1-2 good, 1-2 traps with deal-breakers, 2-3 partial)
+- **Procedural correctness**: Must follow stage order, read replies before messaging, get approval before offering
+
+## Quick Start
+
+```python
+from recruitopenenv import RecruitopenenvEnv, RecruitopenenvAction
+
+env = RecruitopenenvEnv(base_url="YOUR_SPACE_URL")
+
+result = env.reset(seed=42)
+obs = result.observation
+print(f"Driver: {obs.driver_name}, Stage: {obs.stage}")
+
+# Read CRM
+result = env.step(RecruitopenenvAction(tool="crm", action="read_candidate"))
+print(result.observation.jobs_summary)
+
+# Greet driver
+result = env.step(RecruitopenenvAction(tool="messaging", action="send_message", topic="greeting"))
+print(f"Reward: {result.reward}")
+
+# Read reply
+result = env.step(RecruitopenenvAction(tool="messaging", action="read_reply"))
+print(result.observation.discovered_info)
+
+env.close()
+```
+
+## Training
+
+We train using GRPO/REINFORCE with the model choosing screening topics. See `train_grpo.py` for the full training script.
+
+```bash
+python train_grpo.py --model Qwen/Qwen2.5-3B-Instruct
+```
+
+## Deploying
+
+```bash
+# From the recruitopenenv/ directory
+openenv push
+```
+
+## Action Format
+
+```json
+{"tool": "crm", "action": "read_candidate"}
+{"tool": "messaging", "action": "send_message", "topic": "experience"}
+{"tool": "messaging", "action": "read_reply"}
+{"tool": "crm", "action": "update_field", "field": "cdl_class", "value": "A"}
+{"tool": "crm", "action": "update_stage", "stage": "contacted"}
+{"tool": "approval", "action": "request_approval", "job_id": 2}
+{"tool": "workflow", "action": "wait"}
+{"tool": "approval", "action": "check_approval"}
+{"tool": "messaging", "action": "send_message", "topic": "offer", "job_id": 2}
+{"tool": "crm", "action": "update_stage", "stage": "hired"}
+```
+
+## Observation Fields
+
+| Field | Description |
+|-------|-------------|
+| `driver_name` | Driver's name |
+| `crm_summary` | Full CRM record (empty until `read_candidate`) |
+| `jobs_summary` | 6 available job listings |
+| `discovered_info` | Info from screening conversations |
+| `stage` | Current pipeline stage |
+| `feedback` | API response from last action |
+| `pending_reply` | Whether driver has unread message |
+
+## Screening Topics
+
+`greeting`, `call`, `experience`, `home_time`, `pay`, `equipment`, `route`, `deal_breakers`, `availability`, `violations`, `medical_card`, `references`, `pitch`, `offer`, `negotiate_pay`, `negotiate_home_time`, `signing_bonus`, `address_concern`

__init__.py

@@ -0,0 +1,16 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Recruitopenenv Environment."""
+
+from .client import RecruitopenenvEnv
+from .models import RecruitopenenvAction, RecruitopenenvObservation
+
+__all__ = [
+    "RecruitopenenvAction",
+    "RecruitopenenvObservation",
+    "RecruitopenenvEnv",
+]

baseline_llm.py

@@ -0,0 +1,202 @@
+"""LLM agent baseline — test how well a base model performs without RL training."""
+
+import argparse
+import json
+import requests
+from recruitopenenv import RecruitopenenvEnv, RecruitopenenvAction
+
+SYSTEM_PROMPT = """You are a truck driver recruiter using a CRM system. You only know the driver's name. You must discover their qualifications through conversation, record info in the CRM, get approval, and hire them.
+
+You have 4 tools:
+
+## crm
+- read_candidate: Read the current CRM record
+- update_stage: Advance pipeline (contacted → interested → approval_pending → offer_sent → hired)
+- update_field: Record info (field + value)
+- add_note: Add a free-text note
+
+## messaging
+- send_message: Send a message (topic: greeting, call, experience, home_time, pay, equipment, route, deal_breakers, availability, violations, medical_card, references, pitch, offer, negotiate_pay, negotiate_home_time, signing_bonus, address_concern)
+- read_reply: Read the driver's response
+
+## approval
+- request_approval: Request approval for a job (needs job_id)
+- check_approval: Check approval status
+
+## workflow
+- wait: Advance time (needed for approval processing)
+
+## Rules
+- Must read CRM before messaging
+- Must read_reply before sending another message
+- Must request_approval and wait before sending offer
+- Must follow stage order: lead → contacted → interested → approval_pending → offer_sent → hired
+- Record important info in CRM with update_field
+- Too many messages hurt trust
+
+## Strategy
+1. crm.read_candidate → see the lead
+2. messaging.send_message(greeting or call) → messaging.read_reply → crm.update_stage(contacted)
+3. Screen: send_message(experience) → read_reply → update_field(cdl_class, value) ... repeat for key questions
+4. crm.update_stage(interested)
+5. approval.request_approval(job_id) → workflow.wait → approval.check_approval
+6. crm.update_stage(approval_pending)
+7. messaging.send_message(offer) → messaging.read_reply
+8. crm.update_stage(offer_sent) → crm.update_stage(hired)
+
+Tips:
+- ask_experience is critical (CDL class filters jobs)
+- ask_deal_breakers helps avoid trap jobs
+- ask_violations and ask_medical_card reveal fatal blockers
+- If driver has concerns about offer, use negotiate_pay/negotiate_home_time/address_concern
+- If no good match exists, update_stage to lost
+
+Respond with ONLY JSON:
+{"tool": "crm", "action": "read_candidate"}
+{"tool": "messaging", "action": "send_message", "topic": "experience"}
+{"tool": "messaging", "action": "read_reply"}
+{"tool": "crm", "action": "update_field", "field": "cdl_class", "value": "A"}
+{"tool": "approval", "action": "request_approval", "job_id": 2}
+{"tool": "crm", "action": "update_stage", "stage": "hired"}"""
+
+
+def format_observation(obs):
+    parts = [f"Driver: {obs.driver_name}"]
+    if obs.crm_summary:
+        parts.append(f"CRM:\n{obs.crm_summary}")
+    if obs.jobs_summary:
+        parts.append(f"Jobs:\n{obs.jobs_summary}")
+    if obs.discovered_info:
+        parts.append(f"Discovered:\n{obs.discovered_info}")
+    status = f"Stage: {obs.stage}"
+    if obs.pending_reply:
+        status += " | PENDING REPLY"
+    parts.append(status)
+    if obs.feedback:
+        parts.append(f"Result: {obs.feedback}")
+    return "\n".join(parts)
+
+
+def ask_llm(messages, llm_url, model):
+    resp = requests.post(llm_url, json={
+        "model": model,
+        "messages": messages,
+        "temperature": 0.1,
+        "max_tokens": 150,
+    })
+    content = resp.json()["choices"][0]["message"]["content"]
+    return content
+
+
+def parse_action(text):
+    """Try to extract action from LLM response."""
+    text = text.strip()
+
+    # Remove markdown code fences
+    if "```" in text:
+        parts = text.split("```")
+        for part in parts:
+            part = part.strip()
+            if part.startswith("json"):
+                part = part[4:].strip()
+            if part.startswith("{"):
+                text = part
+                break
+
+    # Try JSON parse
+    try:
+        data = json.loads(text)
+        if isinstance(data, dict) and "tool" in data and "action" in data:
+            return RecruitopenenvAction(
+                tool=data["tool"],
+                action=data["action"],
+                topic=data.get("topic", ""),
+                job_id=data.get("job_id", -1),
+                stage=data.get("stage", ""),
+                field=data.get("field", ""),
+                value=data.get("value", ""),
+            )
+    except (json.JSONDecodeError, KeyError):
+        pass
+
+    # Fallback
+    text_lower = text.lower()
+    if "read_candidate" in text_lower:
+        return RecruitopenenvAction(tool="crm", action="read_candidate")
+    if "read_reply" in text_lower:
+        return RecruitopenenvAction(tool="messaging", action="read_reply")
+    if "check_approval" in text_lower:
+        return RecruitopenenvAction(tool="approval", action="check_approval")
+    if "wait" in text_lower:
+        return RecruitopenenvAction(tool="workflow", action="wait")
+
+    return RecruitopenenvAction(tool="crm", action="read_candidate")
+
+
+def run_baseline(env_url, llm_url, model, num_episodes):
+    rewards = []
+    successes = 0
+    total_steps = 0
+
+    env = RecruitopenenvEnv(base_url=env_url)
+
+    for ep in range(num_episodes):
+        result = env.reset()
+        obs = result.observation
+        ep_reward = 0.0
+        steps = 0
+
+        messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+
+        while not result.done and steps < 100:
+            obs_text = format_observation(obs)
+            messages.append({"role": "user", "content": obs_text})
+
+            llm_response = ask_llm(messages, llm_url, model)
+            messages.append({"role": "assistant", "content": llm_response})
+
+            action = parse_action(llm_response)
+            result = env.step(action)
+            obs = result.observation
+            ep_reward += result.reward
+            steps += 1
+
+            print(f"  Step {steps}: {action.tool}.{action.action}"
+                  f"{'(' + action.topic + ')' if action.topic else ''}"
+                  f"{'[job=' + str(action.job_id) + ']' if action.job_id >= 0 else ''}"
+                  f" -> reward={result.reward:.1f}")
+
+        rewards.append(ep_reward)
+        total_steps += steps
+        if obs.stage == "hired":
+            successes += 1
+
+        print(f"Episode {ep+1}: total_reward={ep_reward:.1f}, steps={steps}, "
+              f"{'HIRED' if obs.stage == 'hired' else 'FAIL (' + obs.stage + ')'}")
+        print()
+
+    env.close()
+
+    avg_reward = sum(rewards) / len(rewards)
+    avg_steps = total_steps / num_episodes
+
+    print("\n========== LLM BASELINE (no RL) ==========")
+    print(f"Model:              {model}")
+    print(f"Episodes:           {num_episodes}")
+    print(f"Avg reward:         {avg_reward:.2f}")
+    print(f"Min reward:         {min(rewards):.2f}")
+    print(f"Max reward:         {max(rewards):.2f}")
+    print(f"Hire rate:          {successes}/{num_episodes} ({100*successes/num_episodes:.1f}%)")
+    print(f"Avg steps/episode:  {avg_steps:.1f}")
+    print("==========================================")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="LLM baseline for Driver Recruit Environment")
+    parser.add_argument("--env-url", default="http://localhost:8001", help="Environment server URL")
+    parser.add_argument("--llm-url", default="http://localhost:8033/v1/chat/completions", help="LLM API URL")
+    parser.add_argument("--model", default="Qwen/Qwen2.5-3B-Instruct", help="Model name")
+    parser.add_argument("--episodes", type=int, default=20, help="Number of episodes")
+    args = parser.parse_args()
+
+    run_baseline(args.env_url, args.llm_url, args.model, args.episodes)

baseline_random.py

@@ -0,0 +1,94 @@
+"""Random agent baseline — establishes the floor for reward."""
+
+import random
+from recruitopenenv import RecruitopenenvEnv, RecruitopenenvAction
+
+TOOLS_ACTIONS = {
+    "crm": ["read_candidate", "update_stage", "update_field", "add_note"],
+    "messaging": ["send_message", "read_reply"],
+    "approval": ["request_approval", "check_approval"],
+    "workflow": ["wait"],
+}
+
+TOPICS = [
+    "greeting", "call", "experience", "home_time", "pay", "equipment",
+    "route", "deal_breakers", "availability", "violations", "medical_card",
+    "references", "pitch", "offer", "negotiate_pay", "negotiate_home_time",
+    "signing_bonus", "address_concern",
+]
+
+STAGES = ["contacted", "interested", "approval_pending", "offer_sent", "hired", "lost"]
+
+NUM_EPISODES = 100
+
+
+def random_action():
+    tool = random.choice(list(TOOLS_ACTIONS.keys()))
+    action = random.choice(TOOLS_ACTIONS[tool])
+
+    topic = ""
+    job_id = -1
+    stage = ""
+    field = ""
+    value = ""
+
+    if tool == "messaging" and action == "send_message":
+        topic = random.choice(TOPICS)
+        if topic in ("pitch", "offer"):
+            job_id = random.randint(0, 5)
+    elif tool == "crm" and action == "update_stage":
+        stage = random.choice(STAGES)
+    elif tool == "crm" and action == "update_field":
+        field = random.choice(["cdl_class", "years_exp", "home_time_pref"])
+        value = "A"
+    elif tool == "approval" and action == "request_approval":
+        job_id = random.randint(0, 5)
+
+    return RecruitopenenvAction(
+        tool=tool, action=action, topic=topic,
+        job_id=job_id, stage=stage, field=field, value=value,
+    )
+
+
+def run_baseline():
+    rewards = []
+    successes = 0
+    total_steps = 0
+
+    with RecruitopenenvEnv(base_url="http://localhost:8000").sync() as env:
+        for ep in range(NUM_EPISODES):
+            result = env.reset()
+            ep_reward = 0.0
+            steps = 0
+
+            while not result.done and steps < 100:
+                action = random_action()
+                result = env.step(action)
+                ep_reward += result.reward
+                steps += 1
+
+            rewards.append(ep_reward)
+            total_steps += steps
+
+            if result.observation.stage == "hired":
+                successes += 1
+
+            if (ep + 1) % 10 == 0:
+                avg_so_far = sum(rewards) / len(rewards)
+                print(f"  Episode {ep+1}: reward={ep_reward:.1f}, running avg={avg_so_far:.2f}")
+
+    avg_reward = sum(rewards) / len(rewards)
+    avg_steps = total_steps / NUM_EPISODES
+
+    print("\n========== RANDOM BASELINE ==========")
+    print(f"Episodes:           {NUM_EPISODES}")
+    print(f"Avg reward:         {avg_reward:.2f}")
+    print(f"Min reward:         {min(rewards):.2f}")
+    print(f"Max reward:         {max(rewards):.2f}")
+    print(f"Hire rate:          {successes}/{NUM_EPISODES} ({100*successes/NUM_EPISODES:.1f}%)")
+    print(f"Avg steps/episode:  {avg_steps:.1f}")
+    print("======================================")
+
+
+if __name__ == "__main__":
+    run_baseline()

client.py

@@ -0,0 +1,58 @@
+"""Recruitopenenv Environment Client."""
+
+from typing import Dict
+
+from openenv.core.client_types import StepResult
+from openenv.core.env_server.types import State
+from openenv.core import EnvClient
+
+from .models import RecruitopenenvAction, RecruitopenenvObservation
+
+
+class RecruitopenenvEnv(
+    EnvClient[RecruitopenenvAction, RecruitopenenvObservation, State]
+):
+    """Client for the Driver Recruit Environment."""
+
+    def _step_payload(self, action: RecruitopenenvAction) -> Dict:
+        payload = {
+            "tool": action.tool,
+            "action": action.action,
+        }
+        if action.topic:
+            payload["topic"] = action.topic
+        if action.job_id >= 0:
+            payload["job_id"] = action.job_id
+        if action.stage:
+            payload["stage"] = action.stage
+        if action.field:
+            payload["field"] = action.field
+        if action.value:
+            payload["value"] = action.value
+        return payload
+
+    def _parse_result(self, payload: Dict) -> StepResult[RecruitopenenvObservation]:
+        obs_data = payload.get("observation", {})
+        observation = RecruitopenenvObservation(
+            driver_name=obs_data.get("driver_name", ""),
+            crm_summary=obs_data.get("crm_summary", ""),
+            jobs_summary=obs_data.get("jobs_summary", ""),
+            discovered_info=obs_data.get("discovered_info", ""),
+            stage=obs_data.get("stage", "lead"),
+            feedback=obs_data.get("feedback", ""),
+            pending_reply=obs_data.get("pending_reply", False),
+            done=payload.get("done", False),
+            reward=payload.get("reward", 0.0),
+        )
+
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward", 0.0),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict) -> State:
+        return State(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+        )

demo/index.html

@@ -0,0 +1,724 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Driver Recruit Environment</title>
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link href="https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;500;600&family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+<style>
+*{margin:0;padding:0;box-sizing:border-box}
+:root{
+  --bg:#09090b;--s1:#111113;--s2:#18181b;--s3:#27272a;
+  --b1:#27272a;--b2:#3f3f46;
+  --t1:#fafafa;--t2:#a1a1aa;--t3:#71717a;
+  --green:#22c55e;--red:#ef4444;--amber:#f59e0b;--blue:#3b82f6;--violet:#8b5cf6;--rose:#f43f5e;--cyan:#06b6d4;--orange:#f97316;
+}
+body{font-family:'Inter',system-ui,sans-serif;background:var(--bg);color:var(--t1);-webkit-font-smoothing:antialiased}
+.mono{font-family:'IBM Plex Mono',monospace}
+
+/* ─── HERO ─── */
+.hero{min-height:100vh;display:flex;flex-direction:column;align-items:center;justify-content:center;padding:40px 24px;position:relative;overflow:hidden}
+.hero::before{content:'';position:absolute;top:-200px;left:50%;transform:translateX(-50%);width:800px;height:800px;background:radial-gradient(circle,rgba(139,92,246,0.06) 0%,transparent 70%);pointer-events:none}
+.hero-eyebrow{font-size:13px;font-weight:500;color:var(--violet);letter-spacing:0.08em;text-transform:uppercase;margin-bottom:20px}
+.hero h1{font-size:clamp(2rem,5vw,3.5rem);font-weight:700;letter-spacing:-0.03em;line-height:1.1;text-align:center;max-width:700px;margin-bottom:16px}
+.hero-sub{color:var(--t2);font-size:17px;line-height:1.6;text-align:center;max-width:560px;margin-bottom:48px}
+
+.cards{display:grid;grid-template-columns:repeat(4,1fr);gap:1px;background:var(--b1);border:1px solid var(--b1);border-radius:12px;overflow:hidden;max-width:900px;width:100%;margin-bottom:48px}
+.card{background:var(--s1);padding:24px 20px}
+.card-num{font-family:'IBM Plex Mono',monospace;font-size:12px;color:var(--t3);margin-bottom:10px}
+.card h3{font-size:14px;font-weight:600;margin-bottom:6px}
+.card p{font-size:13px;color:var(--t2);line-height:1.55}
+@media(max-width:800px){.cards{grid-template-columns:1fr 1fr}}
+@media(max-width:500px){.cards{grid-template-columns:1fr}}
+
+.btn{display:inline-flex;align-items:center;gap:8px;padding:12px 28px;border-radius:8px;font-size:14px;font-weight:600;cursor:pointer;border:none;transition:all .15s}
+.btn-white{background:var(--t1);color:var(--bg)}
+.btn-white:hover{opacity:.9}
+
+.env-input{background:var(--s2);border:1px solid var(--b1);color:var(--t2);padding:8px 12px;border-radius:6px;font-size:13px;font-family:'IBM Plex Mono',monospace;width:240px;margin-top:16px;text-align:center}
+.env-input:focus{outline:none;border-color:var(--b2)}
+
+/* ─── GAME ─── */
+.game{display:none;max-width:1280px;margin:0 auto;padding:16px 20px 40px}
+.game.on{display:block}
+
+/* Top bar */
+.topbar{display:flex;align-items:center;justify-content:space-between;padding:12px 0;border-bottom:1px solid var(--b1);margin-bottom:16px;flex-wrap:wrap;gap:12px}
+.topbar-left{display:flex;align-items:center;gap:16px}
+.avatar{width:36px;height:36px;border-radius:50%;background:var(--s3);display:flex;align-items:center;justify-content:center;font-weight:600;font-size:14px;flex-shrink:0}
+.driver-meta h2{font-size:15px;font-weight:600;line-height:1}
+.pill{display:inline-block;font-size:11px;font-weight:500;padding:2px 8px;border-radius:4px;margin-top:4px}
+.pill-chatty{background:rgba(34,197,94,.12);color:var(--green)}
+.pill-professional{background:rgba(59,130,246,.12);color:var(--blue)}
+.pill-impatient{background:rgba(239,68,68,.12);color:var(--red)}
+.pill-suspicious{background:rgba(244,63,94,.12);color:var(--rose)}
+
+.topbar-stats{display:flex;gap:24px;align-items:center}
+.ts{text-align:right}
+.ts-label{font-size:11px;color:var(--t3);text-transform:uppercase;letter-spacing:.05em}
+.ts-val{font-family:'IBM Plex Mono',monospace;font-size:16px;font-weight:600}
+
+.trust-wrap{width:140px}
+.trust-track{width:100%;height:4px;background:var(--s3);border-radius:2px;margin-top:4px;overflow:hidden}
+.trust-fill{height:100%;border-radius:2px;transition:width .4s ease}
+.trust-num{display:flex;justify-content:space-between;align-items:center;margin-top:3px}
+.trust-num span{font-family:'IBM Plex Mono',monospace;font-size:11px;color:var(--t3)}
+.trust-num .delta{font-weight:600}
+.delta-up{color:var(--green)}
+.delta-down{color:var(--red)}
+
+/* Layout */
+.layout{display:grid;grid-template-columns:260px 1fr 260px;gap:16px;min-height:calc(100vh - 120px)}
+@media(max-width:1000px){.layout{grid-template-columns:1fr}}
+.right-col{display:flex;flex-direction:column;gap:12px}
+
+/* Sidebar */
+.sidebar{display:flex;flex-direction:column;gap:12px}
+.pane{background:var(--s1);border:1px solid var(--b1);border-radius:10px;overflow:hidden}
+.pane-head{font-size:11px;font-weight:600;color:var(--t3);text-transform:uppercase;letter-spacing:.06em;padding:12px 14px 8px;display:flex;align-items:center;justify-content:space-between}
+
+.job{padding:10px 14px;border-bottom:1px solid var(--b1);font-size:13px;cursor:default;transition:background .1s}
+.job:last-child{border-bottom:none}
+.job:hover{background:var(--s2)}
+.job-id{font-family:'IBM Plex Mono',monospace;color:var(--t3);font-size:11px;font-weight:500}
+.job-co{font-weight:500;margin-left:6px}
+.job-det{color:var(--t2);font-size:12px;margin-top:3px;line-height:1.5}
+.job-warn{color:var(--amber);font-size:11px;margin-top:2px}
+
+.info-item{padding:8px 14px;border-bottom:1px solid var(--b1);font-size:13px;line-height:1.5}
+.info-item:last-child{border-bottom:none}
+.info-cat{font-family:'IBM Plex Mono',monospace;font-size:10px;font-weight:600;color:var(--violet);text-transform:uppercase;letter-spacing:.04em}
+.info-empty{padding:14px;color:var(--t3);font-size:13px;font-style:italic}
+
+.crm-field{padding:5px 14px;border-bottom:1px solid var(--b1);font-size:12px;display:flex;justify-content:space-between}
+.crm-field:last-child{border-bottom:none}
+.crm-key{color:var(--t3);font-family:'IBM Plex Mono',monospace;font-size:11px}
+.crm-val{color:var(--t1)}
+.crm-empty{padding:14px;color:var(--t3);font-size:13px;font-style:italic}
+
+/* Main area */
+.main{display:flex;flex-direction:column;gap:12px}
+
+/* Timeline */
+.timeline{flex:1;background:var(--s1);border:1px solid var(--b1);border-radius:10px;padding:16px;overflow-y:auto;max-height:calc(100vh - 320px);min-height:320px}
+.tl-entry{display:flex;gap:12px;margin-bottom:16px;animation:slideIn .25s ease}
+@keyframes slideIn{from{opacity:0;transform:translateY(6px)}to{opacity:1;transform:none}}
+.tl-dot-col{display:flex;flex-direction:column;align-items:center;padding-top:4px}
+.tl-dot{width:8px;height:8px;border-radius:50%;flex-shrink:0}
+.tl-line{width:1px;flex:1;background:var(--b1);margin-top:4px}
+.tl-content{flex:1;min-width:0}
+.tl-head{display:flex;align-items:center;gap:8px;margin-bottom:4px;flex-wrap:wrap}
+.tl-action{font-size:13px;font-weight:600}
+.tl-reward{font-family:'IBM Plex Mono',monospace;font-size:12px;font-weight:500}
+.tl-reward.pos{color:var(--green)}.tl-reward.neg{color:var(--red)}.tl-reward.zero{color:var(--t3)}
+.tl-tool-badge{font-size:10px;font-weight:600;padding:1px 6px;border-radius:3px;text-transform:uppercase;letter-spacing:.04em}
+.badge-crm{background:rgba(6,182,212,.12);color:var(--cyan)}
+.badge-messaging{background:rgba(139,92,246,.12);color:var(--violet)}
+.badge-approval{background:rgba(249,115,22,.12);color:var(--orange)}
+.badge-workflow{background:rgba(113,113,122,.15);color:var(--t3)}
+.tl-body{font-size:13px;color:var(--t2);line-height:1.55;padding:8px 12px;background:var(--s2);border-radius:6px;border-left:2px solid var(--b1)}
+.tl-body.good{border-left-color:var(--green)}
+.tl-body.bad{border-left-color:var(--red)}
+.tl-step{font-family:'IBM Plex Mono',monospace;font-size:10px;color:var(--t3)}
+
+/* Tool sections */
+.tool-section{background:var(--s1);border:1px solid var(--b1);border-radius:10px;padding:10px 14px}
+.tool-section-head{font-size:11px;font-weight:600;text-transform:uppercase;letter-spacing:.05em;margin-bottom:8px;display:flex;align-items:center;gap:6px}
+.tool-section-head .dot{width:6px;height:6px;border-radius:50%;display:inline-block}
+
+.act-grid{display:flex;flex-wrap:wrap;gap:6px}
+.act{padding:6px 12px;border-radius:6px;font-size:12px;font-weight:500;cursor:pointer;border:1px solid var(--b1);background:var(--s2);color:var(--t2);transition:all .12s;white-space:nowrap}
+.act:hover{background:var(--s3);color:var(--t1);border-color:var(--b2)}
+.act:disabled{opacity:.3;cursor:not-allowed}
+.act-go{border-color:rgba(34,197,94,.3);color:var(--green)}
+.act-go:hover{background:rgba(34,197,94,.1);border-color:var(--green)}
+.act-no{border-color:rgba(239,68,68,.2);color:var(--red)}
+.act-no:hover{background:rgba(239,68,68,.08);border-color:var(--red)}
+.act-warn{border-color:rgba(245,158,11,.2);color:var(--amber)}
+.act-warn:hover{background:rgba(245,158,11,.08);border-color:var(--amber)}
+
+/* Pipeline */
+.pipeline{background:var(--s1);border:1px solid var(--b1);border-radius:10px;padding:10px 14px}
+.pipe-stages{display:flex;gap:2px;align-items:center}
+.pipe-stage{font-size:10px;font-weight:600;padding:4px 8px;border-radius:4px;text-transform:uppercase;letter-spacing:.04em;background:var(--s2);color:var(--t3);border:1px solid var(--b1)}
+.pipe-stage.active{background:rgba(139,92,246,.15);color:var(--violet);border-color:var(--violet)}
+.pipe-stage.done{background:rgba(34,197,94,.1);color:var(--green);border-color:rgba(34,197,94,.3)}
+.pipe-stage.fail{background:rgba(239,68,68,.1);color:var(--red);border-color:rgba(239,68,68,.3)}
+.pipe-arrow{color:var(--t3);font-size:10px}
+
+/* Pending reply indicator */
+.pending-badge{font-size:11px;font-weight:500;padding:3px 10px;border-radius:4px;background:rgba(139,92,246,.12);color:var(--violet);animation:pulse 1.5s ease infinite}
+@keyframes pulse{0%,100%{opacity:1}50%{opacity:.5}}
+
+/* Modal */
+.modal-bg{display:none;position:fixed;inset:0;background:rgba(0,0,0,.6);z-index:100;align-items:center;justify-content:center;backdrop-filter:blur(4px)}
+.modal-bg.on{display:flex}
+.modal{background:var(--s1);border:1px solid var(--b1);border-radius:12px;padding:20px;width:420px;max-width:90vw}
+.modal h3{font-size:14px;font-weight:600;margin-bottom:14px}
+.modal-job{display:block;width:100%;text-align:left;background:var(--s2);border:1px solid var(--b1);color:var(--t1);padding:10px 12px;border-radius:6px;margin-bottom:6px;cursor:pointer;font-size:13px;transition:border-color .12s}
+.modal-job:hover{border-color:var(--violet)}
+.modal-cancel{display:block;width:100%;text-align:center;background:transparent;border:1px solid var(--b1);color:var(--t3);padding:8px;border-radius:6px;cursor:pointer;font-size:13px;margin-top:8px}
+.modal-cancel:hover{color:var(--t2)}
+
+/* Input modal */
+.modal input[type="text"]{width:100%;background:var(--s2);border:1px solid var(--b1);color:var(--t1);padding:8px 12px;border-radius:6px;font-size:13px;font-family:'IBM Plex Mono',monospace;margin-bottom:8px}
+.modal input[type="text"]:focus{outline:none;border-color:var(--violet)}
+.modal-row{display:flex;gap:8px;margin-top:8px}
+.modal-row .btn{flex:1;justify-content:center;padding:8px;font-size:13px}
+.modal-btn-go{background:var(--violet);color:white;border:none;padding:8px 16px;border-radius:6px;font-size:13px;font-weight:500;cursor:pointer}
+.modal-btn-go:hover{opacity:.9}
+
+/* End screen */
+.endscreen{display:none;position:fixed;inset:0;background:rgba(0,0,0,.75);z-index:200;align-items:center;justify-content:center;backdrop-filter:blur(8px)}
+.endscreen.on{display:flex}
+.end-card{background:var(--s1);border:1px solid var(--b1);border-radius:14px;padding:40px 36px;text-align:center;width:440px;max-width:90vw}
+.end-label{font-size:11px;font-weight:600;text-transform:uppercase;letter-spacing:.1em;margin-bottom:8px}
+.end-title{font-size:28px;font-weight:700;letter-spacing:-0.02em;margin-bottom:6px}
+.end-sub{font-size:13px;color:var(--t2);margin-bottom:28px;line-height:1.5}
+.end-grid{display:grid;grid-template-columns:1fr 1fr 1fr;gap:1px;background:var(--b1);border:1px solid var(--b1);border-radius:8px;overflow:hidden;margin-bottom:24px}
+.end-stat{background:var(--s1);padding:14px 8px}
+.end-stat-val{font-family:'IBM Plex Mono',monospace;font-size:18px;font-weight:600}
+.end-stat-lbl{font-size:11px;color:var(--t3);margin-top:2px}
+
+/* Hidden info toggle */
+.hidden-info.off{display:none}
+.toggle-hidden{background:var(--s2);border:1px solid var(--b1);color:var(--t3);padding:4px 10px;border-radius:4px;font-size:11px;cursor:pointer;margin-left:12px}
+.toggle-hidden:hover{color:var(--t2);border-color:var(--b2)}
+
+/* Stage select */
+.stage-select{background:var(--s2);border:1px solid var(--b1);color:var(--t1);padding:4px 8px;border-radius:4px;font-size:12px;font-family:'IBM Plex Mono',monospace}
+.stage-select:focus{outline:none;border-color:var(--violet)}
+</style>
+</head>
+<body>
+
+<div class="hero" id="hero">
+  <div class="hero-eyebrow">OpenEnv Hackathon &mdash; Long-Horizon RL</div>
+  <h1>Train an AI to recruit truck drivers through tool calls</h1>
+  <p class="hero-sub">A multi-turn RL environment where agents use CRM, messaging, approval, and workflow tools across 40-70 step episodes to screen candidates, avoid trap jobs, and close hires.</p>
+
+  <div class="cards">
+    <div class="card">
+      <div class="card-num mono">01</div>
+      <h3>Tool calling</h3>
+      <p>4 tools &mdash; CRM, messaging, approval, workflow. The agent must call the right tool with the right action at each step.</p>
+    </div>
+    <div class="card">
+      <div class="card-num mono">02</div>
+      <h3>Long horizon</h3>
+      <p>Episodes span 40-70 steps through a full recruiting pipeline: lead &rarr; contacted &rarr; interested &rarr; approval &rarr; offer &rarr; hired.</p>
+    </div>
+    <div class="card">
+      <div class="card-num mono">03</div>
+      <h3>Hidden information</h3>
+      <p>Driver preferences, deal breakers, and personality are hidden. Must be discovered through screening messages.</p>
+    </div>
+    <div class="card">
+      <div class="card-num mono">04</div>
+      <h3>Trap jobs</h3>
+      <p>Jobs that look perfect but violate deal breakers. Skip screening and you'll hire for the wrong one &mdash; big negative reward.</p>
+    </div>
+  </div>
+
+  <button class="btn btn-white" onclick="startGame()">Play the environment</button>
+  <input class="env-input" id="envUrl" value="http://localhost:8000" spellcheck="false">
+</div>
+
+<div class="game" id="game">
+  <div class="topbar">
+    <div class="topbar-left">
+      <div class="avatar" id="av">?</div>
+      <div class="driver-meta">
+        <h2 id="dName">---</h2>
+        <span class="pill" id="dPers"></span>
+      </div>
+    </div>
+    <div class="topbar-stats">
+      <div class="ts">
+        <div class="ts-label">Stage</div>
+        <div class="ts-val" id="uiStage">lead</div>
+      </div>
+      <div class="ts">
+        <div class="ts-label">Step</div>
+        <div class="ts-val"><span id="uiStep">0</span><span style="color:var(--t3)"> / 100</span></div>
+      </div>
+      <div class="ts">
+        <div class="ts-label">Reward</div>
+        <div class="ts-val" id="uiRew">0.0</div>
+      </div>
+      <div id="pendingBadge" style="display:none" class="pending-badge">Unread reply</div>
+      <button class="toggle-hidden" onclick="toggleHidden()">Show hidden</button>
+    </div>
+  </div>
+
+  <!-- Pipeline -->
+  <div class="pipeline">
+    <div class="pipe-stages" id="pipeStages"></div>
+  </div>
+
+  <div class="layout" style="margin-top:12px">
+    <div class="sidebar">
+      <div class="pane" id="jobsPane">
+        <div class="pane-head">Jobs</div>
+        <div id="jobsList"></div>
+      </div>
+      <div class="pane">
+        <div class="pane-head">CRM Record</div>
+        <div id="crmList"><div class="crm-empty">Not loaded &mdash; use crm.read_candidate</div></div>
+      </div>
+    </div>
+    <div class="main">
+      <div class="timeline" id="tl"></div>
+
+      <!-- Tool: CRM -->
+      <div class="tool-section">
+        <div class="tool-section-head"><span class="dot" style="background:var(--cyan)"></span><span style="color:var(--cyan)">CRM</span></div>
+        <div class="act-grid">
+          <button class="act" onclick="doTool('crm','read_candidate')">read_candidate</button>
+          <button class="act" onclick="showStageModal()">update_stage</button>
+          <button class="act" onclick="showFieldModal()">update_field</button>
+          <button class="act" onclick="showNoteModal()">add_note</button>
+        </div>
+      </div>
+
+      <!-- Tool: Messaging -->
+      <div class="tool-section">
+        <div class="tool-section-head"><span class="dot" style="background:var(--violet)"></span><span style="color:var(--violet)">Messaging</span></div>
+        <div class="act-grid" id="msgGrid">
+          <button class="act" onclick="doMsg('greeting')">greeting</button>
+          <button class="act" onclick="doMsg('call')">call</button>
+          <span style="width:1px;height:24px;background:var(--b1)"></span>
+          <button class="act" onclick="doMsg('experience')">experience</button>
+          <button class="act" onclick="doMsg('home_time')">home time</button>
+          <button class="act" onclick="doMsg('pay')">pay</button>
+          <button class="act" onclick="doMsg('equipment')">equipment</button>
+          <button class="act" onclick="doMsg('route')">route</button>
+          <button class="act" onclick="doMsg('deal_breakers')">deal breakers</button>
+          <button class="act" onclick="doMsg('availability')">availability</button>
+          <button class="act" onclick="doMsg('violations')">violations</button>
+          <button class="act" onclick="doMsg('medical_card')">medical card</button>
+          <button class="act" onclick="doMsg('references')">references</button>
+          <span style="width:1px;height:24px;background:var(--b1)"></span>
+          <button class="act act-warn" onclick="showJobModal('pitch')">pitch job</button>
+          <button class="act act-warn" onclick="showJobModal('offer')">send offer</button>
+          <span style="width:1px;height:24px;background:var(--b1)"></span>
+          <button class="act" onclick="doMsg('negotiate_pay')">negotiate pay</button>
+          <button class="act" onclick="doMsg('negotiate_home_time')">negotiate home</button>
+          <button class="act" onclick="doMsg('signing_bonus')">signing bonus</button>
+          <button class="act" onclick="doMsg('address_concern')">address concern</button>
+          <span style="width:1px;height:24px;background:var(--b1)"></span>
+          <button class="act act-go" onclick="doTool('messaging','read_reply')">read_reply</button>
+        </div>
+      </div>
+
+      <!-- Tool: Approval + Workflow -->
+      <div style="display:flex;gap:12px">
+        <div class="tool-section" style="flex:1">
+          <div class="tool-section-head"><span class="dot" style="background:var(--orange)"></span><span style="color:var(--orange)">Approval</span></div>
+          <div class="act-grid">
+            <button class="act" onclick="showJobModal('request_approval')">request_approval</button>
+            <button class="act" onclick="doTool('approval','check_approval')">check_approval</button>
+          </div>
+        </div>
+        <div class="tool-section" style="flex:1">
+          <div class="tool-section-head"><span class="dot" style="background:var(--t3)"></span><span style="color:var(--t3)">Workflow</span></div>
+          <div class="act-grid">
+            <button class="act" onclick="doTool('workflow','wait')">wait</button>
+            <button class="act act-go" onclick="showStageModal('hired')">hire (finish)</button>
+            <button class="act act-no" onclick="doStage('lost')">reject (lost)</button>
+          </div>
+        </div>
+      </div>
+    </div>
+    <div class="right-col">
+      <div class="pane">
+        <div class="pane-head">Discovered Info</div>
+        <div id="infoList"><div class="info-empty">No info yet &mdash; send messages and read replies</div></div>
+      </div>
+    </div>
+  </div>
+</div>
+
+<!-- Job picker modal -->
+<div class="modal-bg" id="modalBg">
+  <div class="modal">
+    <h3 id="modalTitle">Select job</h3>
+    <div id="modalJobs"></div>
+    <button class="modal-cancel" onclick="closeModal()">Cancel</button>
+  </div>
+</div>
+
+<!-- Stage modal -->
+<div class="modal-bg" id="stageModalBg">
+  <div class="modal">
+    <h3>Update Pipeline Stage</h3>
+    <div id="stageModalBtns"></div>
+    <button class="modal-cancel" onclick="closeStageModal()">Cancel</button>
+  </div>
+</div>
+
+<!-- Field modal -->
+<div class="modal-bg" id="fieldModalBg">
+  <div class="modal">
+    <h3>Update CRM Field</h3>
+    <select id="fieldSelect" class="stage-select" style="width:100%;margin-bottom:8px;padding:8px">
+      <option value="cdl_class">cdl_class</option>
+      <option value="years_experience">years_experience</option>
+      <option value="endorsements">endorsements</option>
+      <option value="location">location</option>
+      <option value="home_time_pref">home_time_pref</option>
+      <option value="pay_expectation">pay_expectation</option>
+      <option value="equipment_pref">equipment_pref</option>
+      <option value="route_pref">route_pref</option>
+      <option value="deal_breakers">deal_breakers</option>
+      <option value="availability">availability</option>
+      <option value="violations">violations</option>
+      <option value="medical_card">medical_card</option>
+      <option value="references">references</option>
+      <option value="matched_job">matched_job</option>
+    </select>
+    <input type="text" id="fieldValue" placeholder="Value..." />
+    <div class="modal-row">
+      <button class="modal-btn-go" onclick="submitField()">Save</button>
+      <button class="modal-cancel" onclick="closeFieldModal()" style="margin-top:0">Cancel</button>
+    </div>
+  </div>
+</div>
+
+<!-- Note modal -->
+<div class="modal-bg" id="noteModalBg">
+  <div class="modal">
+    <h3>Add CRM Note</h3>
+    <input type="text" id="noteValue" placeholder="Note text..." />
+    <div class="modal-row">
+      <button class="modal-btn-go" onclick="submitNote()">Add</button>
+      <button class="modal-cancel" onclick="closeNoteModal()" style="margin-top:0">Cancel</button>
+    </div>
+  </div>
+</div>
+
+<!-- End screen -->
+<div class="endscreen" id="endscreen">
+  <div class="end-card">
+    <div class="end-label" id="endLabel"></div>
+    <div class="end-title" id="endTitle"></div>
+    <div class="end-sub" id="endSub"></div>
+    <div class="end-grid">
+      <div class="end-stat"><div class="end-stat-val" id="erRew"></div><div class="end-stat-lbl">Reward</div></div>
+      <div class="end-stat"><div class="end-stat-val" id="erStep"></div><div class="end-stat-lbl">Steps</div></div>
+      <div class="end-stat"><div class="end-stat-val" id="erStage"></div><div class="end-stat-lbl">Final Stage</div></div>
+    </div>
+    <button class="btn btn-white" onclick="startGame()">Play again</button>
+  </div>
+</div>
+
+<script>
+let ENV='',WS=null;
+let S={obs:null,rew:0,done:false,jobs:[],stepCount:0};
+let showHidden=false;
+
+const STAGES=['lead','contacted','interested','approval_pending','offer_sent','hired'];
+const FAIL_STAGES=['lost','ghosted'];
+
+function toggleHidden(){
+  showHidden=!showHidden;
+  document.querySelectorAll('.hidden-info').forEach(el=>el.classList.toggle('off',!showHidden));
+  document.querySelector('.toggle-hidden').textContent=showHidden?'Hide hidden':'Show hidden';
+}
+
+function wsUrl(){
+  const base=document.getElementById('envUrl').value.replace(/\/$/,'');
+  return base.replace(/^http/,'ws')+'/ws';
+}
+
+function connectWS(){
+  return new Promise((resolve,reject)=>{
+    if(WS&&WS.readyState===WebSocket.OPEN){resolve();return}
+    if(WS)WS.close();
+    WS=new WebSocket(wsUrl());
+    WS.onopen=()=>resolve();
+    WS.onerror=()=>reject(new Error('WebSocket connection failed'));
+    WS.onmessage=(ev)=>{
+      const msg=JSON.parse(ev.data);
+      if(msg.type==='error'){
+        console.error('WS error:',msg.data);
+        if(pendingResolve){pendingResolve=null;}
+        return;
+      }
+      if(msg.type==='observation'&&pendingResolve){
+        const cb=pendingResolve;pendingResolve=null;
+        cb(msg.data);
+      }
+    };
+    WS.onclose=()=>{WS=null};
+  });
+}
+
+let pendingResolve=null;
+function wsSend(msg){
+  return new Promise(resolve=>{
+    pendingResolve=resolve;
+    WS.send(JSON.stringify(msg));
+  });
+}
+
+async function startGame(){
+  document.getElementById('hero').style.display='none';
+  document.getElementById('game').classList.add('on');
+  document.getElementById('endscreen').classList.remove('on');
+  document.getElementById('tl').innerHTML='';
+  S={obs:null,rew:0,done:false,jobs:[],stepCount:0};
+  try{
+    await connectWS();
+    const d=await wsSend({type:'reset'});
+    handle(d,null);
+  }catch(e){
+    alert('Cannot reach server: '+e.message);
+    document.getElementById('hero').style.display='';
+    document.getElementById('game').classList.remove('on');
+  }
+}
+
+// --- Tool actions ---
+async function doTool(tool,action,extra){
+  if(S.done||!WS)return;
+  const data={tool,action,...(extra||{})};
+  const d=await wsSend({type:'step',data});
+  handle(d,tool+'.'+action,data);
+}
+
+async function doMsg(topic,jobId){
+  const extra={topic};
+  if(jobId!==undefined)extra.job_id=jobId;
+  await doTool('messaging','send_message',extra);
+}
+
+async function doStage(stage){
+  await doTool('crm','update_stage',{stage});
+}
+
+// --- Handle response ---
+function handle(d,label,actionData){
+  const o=d.observation,rw=d.reward||0;
+  S.obs=o; S.rew+=rw; S.done=d.done;
+  if(o.steps_taken!==undefined)S.stepCount=o.steps_taken;
+  else if(label)S.stepCount++;
+  render(o,rw,label,actionData);
+  if(d.done)setTimeout(()=>showEnd(o),500);
+}
+
+function render(o,rw,label,actionData){
+  // Driver info
+  document.getElementById('dName').textContent=o.driver_name;
+  document.getElementById('av').textContent=o.driver_name?o.driver_name[0]:'?';
+
+  // Stage
+  document.getElementById('uiStage').textContent=o.stage;
+  document.getElementById('uiStep').textContent=S.stepCount;
+
+  // Reward
+  const re=document.getElementById('uiRew');
+  re.textContent=(S.rew>=0?'+':'')+S.rew.toFixed(1);
+  re.style.color=S.rew>=0?'var(--green)':'var(--red)';
+
+  // Pending reply
+  document.getElementById('pendingBadge').style.display=o.pending_reply?'':'none';
+
+  // Pipeline
+  renderPipeline(o.stage);
+
+  // Jobs
+  if(o.jobs_summary){
+    const lines=o.jobs_summary.split('\n');
+    document.getElementById('jobsList').innerHTML=lines.map(l=>{
+      const fm=l.match(/\[(.+?)\]/);
+      const warn=fm?'<div class="job-warn">'+fm[1]+'</div>':'';
+      const parts=l.split(' \u2014 ');
+      const hd=parts[0]||'';
+      const det=parts[1]||'';
+      const im=hd.match(/^Job (\d+): (.+)/);
+      return '<div class="job"><span class="job-id">#'+((im&&im[1])||'?')+'</span><span class="job-co">'+((im&&im[2])||hd)+'</span><div class="job-det">'+det+'</div>'+warn+'</div>';
+    }).join('');
+    S.jobs=lines.map(l=>{const m=l.match(/^Job (\d+): (.+?) \u2014/);return m?{id:+m[1],label:'#'+m[1]+' '+m[2]}:null}).filter(Boolean);
+  }
+
+  // CRM
+  if(o.crm_summary){
+    const lines=o.crm_summary.split('\n');
+    let html='';
+    lines.forEach(l=>{
+      const fieldMatch=l.match(/^\s{2}(\w+):\s*(.+)/);
+      if(fieldMatch){
+        html+='<div class="crm-field"><span class="crm-key">'+fieldMatch[1]+'</span><span class="crm-val">'+fieldMatch[2]+'</span></div>';
+      } else if(l.startsWith('Name:')||l.startsWith('Stage:')){
+        html+='<div class="crm-field"><span class="crm-key">'+l.split(':')[0]+'</span><span class="crm-val">'+l.split(':').slice(1).join(':').trim()+'</span></div>';
+      } else if(l.trim()==='Fields: (none recorded)'){
+        html+='<div class="crm-field"><span class="crm-key" style="color:var(--t3)">no fields recorded</span></div>';
+      } else if(l.match(/^\s{2}-\s(.+)/)){
+        html+='<div class="crm-field"><span class="crm-key">note</span><span class="crm-val" style="font-style:italic">'+l.match(/^\s{2}-\s(.+)/)[1]+'</span></div>';
+      }
+    });
+    document.getElementById('crmList').innerHTML=html||'<div class="crm-empty">Empty CRM</div>';
+  }
+
+  // Discovered info
+  if(o.discovered_info){
+    const items=o.discovered_info.split('\n').filter(l=>l.trim());
+    document.getElementById('infoList').innerHTML=items.map(l=>{
+      const m=l.match(/^\[(.+?)\]\s*(.*)/);
+      if(m)return '<div class="info-item"><span class="info-cat">'+m[1]+'</span><br>'+m[2]+'</div>';
+      return '<div class="info-item">'+l+'</div>';
+    }).join('');
+  }
+
+  // Timeline
+  if(label){
+    const tl=document.getElementById('tl');
+    const rwClass=rw>0?'pos':rw<0?'neg':'zero';
+    const rwStr=rw>=0?'+'+rw.toFixed(1):rw.toFixed(1);
+    const dotColor=rw>0?'var(--green)':rw<0?'var(--red)':'var(--b2)';
+    const bodyClass=rw>0?'good':rw<0?'bad':'';
+
+    // Tool badge
+    let toolName='';
+    if(actionData&&actionData.tool)toolName=actionData.tool;
+    else if(label.includes('.'))toolName=label.split('.')[0];
+    const badgeClass={'crm':'badge-crm','messaging':'badge-messaging','approval':'badge-approval','workflow':'badge-workflow'}[toolName]||'badge-workflow';
+    const badge=toolName?'<span class="tl-tool-badge '+badgeClass+'">'+toolName+'</span>':'';
+
+    // Parse feedback for display
+    let feedbackText='';
+    if(o.feedback){
+      try{
+        const fb=JSON.parse(o.feedback);
+        if(fb.reply)feedbackText=fb.reply;
+        else if(fb.message)feedbackText=fb.message;
+        else if(fb.error)feedbackText='Error: '+fb.error;
+        else if(fb.result)feedbackText='Result: '+fb.result+(fb.reason?' ('+fb.reason+')':'');
+        else if(fb.approval_status)feedbackText='Approval: '+fb.approval_status;
+        else if(fb.stage)feedbackText='Stage updated: '+fb.stage;
+        else if(fb.field)feedbackText=fb.field+' = '+fb.value;
+        else if(fb.elapsed)feedbackText='Time elapsed: '+fb.elapsed;
+        else feedbackText=o.feedback;
+      }catch(e){feedbackText=o.feedback}
+    }
+
+    let html='<div class="tl-entry"><div class="tl-dot-col"><div class="tl-dot" style="background:'+dotColor+'"></div><div class="tl-line"></div></div><div class="tl-content"><div class="tl-head"><span class="tl-step mono">'+S.stepCount+'</span>'+badge+'<span class="tl-action">'+label+'</span><span class="tl-reward '+rwClass+'">'+rwStr+'</span></div>';
+    if(feedbackText)html+='<div class="tl-body '+bodyClass+'">'+feedbackText+'</div>';
+    html+='</div></div>';
+    tl.innerHTML+=html;
+    tl.scrollTop=tl.scrollHeight;
+  } else if(o.feedback){
+    const tl=document.getElementById('tl');
+    let feedbackText='';
+    try{
+      const fb=JSON.parse(o.feedback);
+      feedbackText='New episode: '+o.driver_name+' &mdash; '+fb.jobs+' jobs available';
+    }catch(e){feedbackText=o.feedback}
+    tl.innerHTML+='<div class="tl-entry"><div class="tl-dot-col"><div class="tl-dot" style="background:var(--violet)"></div><div class="tl-line"></div></div><div class="tl-content"><div class="tl-head"><span class="tl-step mono">0</span><span class="tl-action">Episode start</span></div><div class="tl-body">'+feedbackText+'</div></div></div>';
+  }
+}
+
+function renderPipeline(currentStage){
+  const el=document.getElementById('pipeStages');
+  const failStage=FAIL_STAGES.includes(currentStage)?currentStage:null;
+  const curIdx=STAGES.indexOf(currentStage);
+  let html='';
+  STAGES.forEach((s,i)=>{
+    let cls='pipe-stage';
+    if(failStage){cls+=' fail'}
+    else if(i<curIdx)cls+=' done';
+    else if(i===curIdx)cls+=' active';
+    html+='<span class="'+cls+'">'+s.replace('_',' ')+'</span>';
+    if(i<STAGES.length-1)html+='<span class="pipe-arrow">&rarr;</span>';
+  });
+  if(failStage){
+    html+='<span class="pipe-arrow">&rarr;</span><span class="pipe-stage fail">'+failStage+'</span>';
+  }
+  el.innerHTML=html;
+}
+
+// --- Modals ---
+let pendingModalAction='';
+
+function showJobModal(action){
+  pendingModalAction=action;
+  const titles={'pitch':'Pitch which job?','offer':'Send offer for which job?','request_approval':'Request approval for which job?'};
+  document.getElementById('modalTitle').textContent=titles[action]||'Select job';
+  document.getElementById('modalJobs').innerHTML=S.jobs.map(j=>'<button class="modal-job" onclick="selJob('+j.id+')">'+j.label+'</button>').join('');
+  document.getElementById('modalBg').classList.add('on');
+}
+function selJob(id){
+  closeModal();
+  if(pendingModalAction==='pitch'||pendingModalAction==='offer'){
+    doMsg(pendingModalAction,id);
+  } else if(pendingModalAction==='request_approval'){
+    doTool('approval','request_approval',{job_id:id});
+  }
+}
+function closeModal(){document.getElementById('modalBg').classList.remove('on')}
+
+function showStageModal(preselect){
+  const stages=['contacted','interested','approval_pending','offer_sent','hired','lost'];
+  document.getElementById('stageModalBtns').innerHTML=stages.map(s=>{
+    const cls=s==='hired'?'modal-job" style="border-color:var(--green);color:var(--green)':s==='lost'?'modal-job" style="border-color:var(--red);color:var(--red)':'modal-job';
+    return '<button class="'+cls+'" onclick="doStage(\''+s+'\');closeStageModal()">'+s.replace('_',' ')+'</button>';
+  }).join('');
+  document.getElementById('stageModalBg').classList.add('on');
+}
+function closeStageModal(){document.getElementById('stageModalBg').classList.remove('on')}
+
+function showFieldModal(){document.getElementById('fieldModalBg').classList.add('on');document.getElementById('fieldValue').value='';document.getElementById('fieldValue').focus()}
+function closeFieldModal(){document.getElementById('fieldModalBg').classList.remove('on')}
+function submitField(){
+  const f=document.getElementById('fieldSelect').value;
+  const v=document.getElementById('fieldValue').value;
+  if(!v)return;
+  closeFieldModal();
+  doTool('crm','update_field',{field:f,value:v});
+}
+
+function showNoteModal(){document.getElementById('noteModalBg').classList.add('on');document.getElementById('noteValue').value='';document.getElementById('noteValue').focus()}
+function closeNoteModal(){document.getElementById('noteModalBg').classList.remove('on')}
+function submitNote(){
+  const v=document.getElementById('noteValue').value;
+  if(!v)return;
+  closeNoteModal();
+  doTool('crm','add_note',{value:v});
+}
+
+// --- End screen ---
+function showEnd(o){
+  const e=document.getElementById('endscreen');e.classList.add('on');
+  const win=o.stage==='hired';
+  document.getElementById('endLabel').textContent=win?'DRIVER HIRED':'EPISODE ENDED';
+  document.getElementById('endLabel').style.color=win?'var(--green)':'var(--red)';
+  document.getElementById('endTitle').textContent=win?'Placement complete':o.stage==='ghosted'?'Driver ghosted':'Failed';
+  document.getElementById('endTitle').style.color=win?'var(--green)':'var(--t1)';
+
+  let subText='';
+  if(o.feedback){
+    try{
+      const fb=JSON.parse(o.feedback);
+      if(fb.reason)subText=fb.reason.replace(/_/g,' ');
+      if(fb.result)subText=fb.result.replace(/_/g,' ')+(subText?' &mdash; '+subText:'');
+      if(fb.score)subText+=' (fit score: '+fb.score+')';
+      if(fb.crm_bonus)subText+=' CRM bonus: +'+fb.crm_bonus;
+    }catch(e){subText=o.feedback}
+  }
+  document.getElementById('endSub').innerHTML=subText;
+
+  const rv=document.getElementById('erRew');
+  rv.textContent=(S.rew>=0?'+':'')+S.rew.toFixed(1);
+  rv.style.color=S.rew>=0?'var(--green)':'var(--red)';
+  document.getElementById('erStep').textContent=S.stepCount;
+  document.getElementById('erStage').textContent=o.stage;
+}
+
+// Enter to submit in modals
+document.getElementById('fieldValue').addEventListener('keydown',e=>{if(e.key==='Enter')submitField()});
+document.getElementById('noteValue').addEventListener('keydown',e=>{if(e.key==='Enter')submitNote()});
+</script>
+</body>
+</html>

eval_trained.py

@@ -0,0 +1,209 @@
+"""Evaluate a trained model against the recruiting environment."""
+
+import argparse
+import json
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import torch
+from recruitopenenv import RecruitopenenvEnv, RecruitopenenvAction
+
+SYSTEM_PROMPT = """You are a truck driver recruiter using a CRM system. You only know the driver's name. You must discover their qualifications through conversation, record info in the CRM, get approval, and hire them.
+
+You have 4 tools:
+
+## crm
+- read_candidate: Read the current CRM record
+- update_stage: Advance pipeline (contacted → interested → approval_pending → offer_sent → hired)
+- update_field: Record info (field + value)
+- add_note: Add a free-text note
+
+## messaging
+- send_message: Send a message (topic: greeting, call, experience, home_time, pay, equipment, route, deal_breakers, availability, violations, medical_card, references, pitch, offer, negotiate_pay, negotiate_home_time, signing_bonus, address_concern)
+- read_reply: Read the driver's response
+
+## approval
+- request_approval: Request approval for a job (needs job_id)
+- check_approval: Check approval status
+
+## workflow
+- wait: Advance time (needed for approval processing)
+
+## Rules
+- Must read CRM before messaging
+- Must read_reply before sending another message
+- Must request_approval and wait before sending offer
+- Must follow stage order: lead → contacted → interested → approval_pending → offer_sent → hired
+- Record important info in CRM with update_field
+
+Respond with ONLY JSON:
+{"tool": "crm", "action": "read_candidate"}
+{"tool": "messaging", "action": "send_message", "topic": "experience"}
+{"tool": "messaging", "action": "read_reply"}
+{"tool": "crm", "action": "update_field", "field": "cdl_class", "value": "A"}
+{"tool": "crm", "action": "update_stage", "stage": "contacted"}
+{"tool": "approval", "action": "request_approval", "job_id": 2}
+{"tool": "workflow", "action": "wait"}
+{"tool": "approval", "action": "check_approval"}
+{"tool": "messaging", "action": "send_message", "topic": "offer", "job_id": 2}
+{"tool": "crm", "action": "update_stage", "stage": "hired"}"""
+
+
+def format_observation(obs):
+    parts = [f"Driver: {obs.driver_name}"]
+    if obs.crm_summary:
+        parts.append(f"CRM:\n{obs.crm_summary}")
+    if obs.jobs_summary:
+        parts.append(f"Jobs:\n{obs.jobs_summary}")
+    if obs.discovered_info:
+        parts.append(f"Discovered:\n{obs.discovered_info}")
+    status = f"Stage: {obs.stage}"
+    if obs.pending_reply:
+        status += " | PENDING REPLY"
+    parts.append(status)
+    if obs.feedback:
+        parts.append(f"Result: {obs.feedback}")
+    return "\n".join(parts)
+
+
+def parse_action(text):
+    text = text.strip()
+    if "```" in text:
+        for part in text.split("```"):
+            part = part.strip()
+            if part.startswith("json"):
+                part = part[4:].strip()
+            if part.startswith("{"):
+                text = part
+                break
+    try:
+        data = json.loads(text)
+        if isinstance(data, list):
+            data = data[0] if data else {}
+        if isinstance(data, dict) and "tool" in data and "action" in data:
+            return RecruitopenenvAction(
+                tool=data["tool"],
+                action=data["action"],
+                topic=data.get("topic", ""),
+                job_id=data.get("job_id", -1),
+                stage=data.get("stage", ""),
+                field=data.get("field", ""),
+                value=data.get("value", ""),
+            )
+    except (json.JSONDecodeError, KeyError, IndexError):
+        pass
+
+    text_lower = text.lower()
+    if "read_candidate" in text_lower:
+        return RecruitopenenvAction(tool="crm", action="read_candidate")
+    if "read_reply" in text_lower:
+        return RecruitopenenvAction(tool="messaging", action="read_reply")
+    if "check_approval" in text_lower:
+        return RecruitopenenvAction(tool="approval", action="check_approval")
+    if "wait" in text_lower:
+        return RecruitopenenvAction(tool="workflow", action="wait")
+
+    return RecruitopenenvAction(tool="crm", action="read_candidate")
+
+
+def generate(model, tokenizer, messages, device):
+    prompt = tokenizer.apply_chat_template(
+        messages, add_generation_prompt=True, tokenize=False
+    )
+    inputs = tokenizer(prompt, return_tensors="pt").to(device)
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=128,
+            temperature=0.1,
+            do_sample=True,
+            pad_token_id=tokenizer.eos_token_id,
+        )
+    new_tokens = outputs[0][inputs["input_ids"].shape[1]:]
+    return tokenizer.decode(new_tokens, skip_special_tokens=True)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", default="./recruit-grpo-output", help="Path to trained model")
+    parser.add_argument("--base-model", default="Qwen/Qwen2.5-1.5B-Instruct", help="Base model for comparison")
+    parser.add_argument("--env-url", default="http://localhost:8001")
+    parser.add_argument("--num-episodes", type=int, default=20)
+    parser.add_argument("--compare", action="store_true", help="Also run base model for comparison")
+    args = parser.parse_args()
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    models_to_eval = [("TRAINED", args.model)]
+    if args.compare:
+        models_to_eval.append(("BASE", args.base_model))
+
+    for label, model_path in models_to_eval:
+        print(f"\n{'='*50}")
+        print(f"Evaluating: {label} ({model_path})")
+        print(f"{'='*50}")
+
+        tokenizer = AutoTokenizer.from_pretrained(model_path)
+        model = AutoModelForCausalLM.from_pretrained(
+            model_path, torch_dtype=torch.float16, device_map="auto"
+        )
+
+        rewards = []
+        successes = 0
+        total_steps = 0
+
+        with RecruitopenenvEnv(base_url=args.env_url) as env:
+            for ep in range(args.num_episodes):
+                result = env.reset()
+                obs = result.observation
+                ep_reward = 0.0
+                steps = 0
+                messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+
+                while not result.done and steps < 100:
+                    obs_text = format_observation(obs)
+                    messages.append({"role": "user", "content": obs_text})
+
+                    response = generate(model, tokenizer, messages, device)
+                    messages.append({"role": "assistant", "content": response})
+
+                    action = parse_action(response)
+                    result = env.step(action)
+                    obs = result.observation
+                    ep_reward += result.reward
+                    steps += 1
+
+                    print(f"  Step {steps}: {action.tool}.{action.action}"
+                          f"{'(' + action.topic + ')' if action.topic else ''}"
+                          f"{'[job=' + str(action.job_id) + ']' if action.job_id >= 0 else ''}"
+                          f" -> reward={result.reward:.1f}")
+
+                rewards.append(ep_reward)
+                total_steps += steps
+                hired = obs.stage == "hired"
+                if hired:
+                    successes += 1
+
+                print(f"Episode {ep+1}: reward={ep_reward:.1f}, steps={steps}, "
+                      f"{'HIRED' if hired else 'FAIL (' + obs.stage + ')'}")
+                print()
+
+        avg_reward = sum(rewards) / len(rewards)
+        avg_steps = total_steps / args.num_episodes
+
+        print(f"\n{'='*40}")
+        print(f"  {label} RESULTS")
+        print(f"{'='*40}")
+        print(f"Model:              {model_path}")
+        print(f"Episodes:           {args.num_episodes}")
+        print(f"Avg reward:         {avg_reward:.2f}")
+        print(f"Min reward:         {min(rewards):.2f}")
+        print(f"Max reward:         {max(rewards):.2f}")
+        print(f"Hire rate:          {successes}/{args.num_episodes} ({100*successes/args.num_episodes:.1f}%)")
+        print(f"Avg steps/episode:  {avg_steps:.1f}")
+        print(f"{'='*40}")
+
+        del model
+        torch.cuda.empty_cache()
+
+
+if __name__ == "__main__":
+    main()

models.py

@@ -0,0 +1,67 @@
+"""
+Data models for the Driver Recruit Environment.
+
+Tool-based action interface for long-horizon recruiting pipeline.
+Agent uses CRM, messaging, approval, and workflow tools.
+"""
+
+from pydantic import Field
+
+from openenv.core.env_server.types import Action, Observation
+
+
+class RecruitopenenvAction(Action):
+    """Tool-based action the agent takes."""
+
+    tool: str = Field(
+        ...,
+        description="Tool: crm, messaging, approval, workflow",
+    )
+    action: str = Field(
+        ...,
+        description=(
+            "Action within tool. "
+            "crm: read_candidate, update_stage, update_field, add_note. "
+            "messaging: send_message, read_reply. "
+            "approval: request_approval, check_approval. "
+            "workflow: wait."
+        ),
+    )
+    topic: str = Field(
+        default="",
+        description=(
+            "Message topic for messaging.send_message: "
+            "greeting, call, experience, home_time, pay, equipment, route, "
+            "deal_breakers, availability, violations, medical_card, references, "
+            "pitch, offer, negotiate_pay, negotiate_home_time, signing_bonus, address_concern"
+        ),
+    )
+    job_id: int = Field(
+        default=-1,
+        description="Job index (0-5). Used with pitch, offer, request_approval.",
+    )
+    stage: str = Field(
+        default="",
+        description="Target stage for crm.update_stage: contacted, interested, approval_pending, offer_sent, hired, lost",
+    )
+    field: str = Field(
+        default="",
+        description="CRM field for crm.update_field",
+    )
+    value: str = Field(
+        default="",
+        description="Value for crm.update_field or text for crm.add_note",
+    )
+
+
+class RecruitopenenvObservation(Observation):
+    """What the agent sees after each action."""
+
+    driver_name: str = Field(default="", description="Driver's name")
+    crm_summary: str = Field(default="", description="CRM record (empty until read_candidate)")
+    jobs_summary: str = Field(default="", description="Available job listings")
+    discovered_info: str = Field(default="", description="Info discovered through conversation")
+
+    stage: str = Field(default="lead", description="Current pipeline stage")
+    feedback: str = Field(default="", description="API response from last action")
+    pending_reply: bool = Field(default=False, description="Whether an unread message is waiting")

openenv.yaml

@@ -0,0 +1,7 @@
+spec_version: 1
+name: recruitopenenv
+type: space
+runtime: fastapi
+app: server.app:app
+port: 8000
+

openenv_recruitopenenv.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: openenv-recruitopenenv
+Version: 0.1.0
+Summary: Recruitopenenv environment for OpenEnv
+Requires-Python: >=3.10
+Requires-Dist: openenv-core[core]>=0.2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

openenv_recruitopenenv.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+__init__.py
+client.py
+models.py
+pyproject.toml
+./__init__.py
+./client.py
+./models.py
+openenv_recruitopenenv.egg-info/PKG-INFO
+openenv_recruitopenenv.egg-info/SOURCES.txt
+openenv_recruitopenenv.egg-info/dependency_links.txt
+openenv_recruitopenenv.egg-info/entry_points.txt
+openenv_recruitopenenv.egg-info/requires.txt
+openenv_recruitopenenv.egg-info/top_level.txt
+server/__init__.py
+server/app.py
+server/recruitopenenv_environment.py

openenv_recruitopenenv.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openenv_recruitopenenv.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+server = recruitopenenv.server.app:main

openenv_recruitopenenv.egg-info/requires.txt

@@ -0,0 +1,5 @@
+openenv-core[core]>=0.2.0
+
+[dev]
+pytest>=8.0.0
+pytest-cov>=4.0.0

openenv_recruitopenenv.egg-info/top_level.txt

@@ -0,0 +1 @@
+recruitopenenv

play.py

@@ -0,0 +1,172 @@
+"""Interactive CLI to play the recruiting environment manually."""
+
+import json
+import requests
+
+BASE_URL = "http://localhost:8000"
+
+SHORTCUTS = {
+    "r": '{"tool":"crm","action":"read_candidate"}',
+    "rr": '{"tool":"messaging","action":"read_reply"}',
+    "w": '{"tool":"workflow","action":"wait"}',
+    "ca": '{"tool":"approval","action":"check_approval"}',
+    "hi": '{"tool":"crm","action":"update_stage","stage":"hired"}',
+    "lost": '{"tool":"crm","action":"update_stage","stage":"lost"}',
+}
+
+TOPIC_SHORTCUTS = {
+    "g": "greeting", "c": "call", "exp": "experience", "ht": "home_time",
+    "pay": "pay", "eq": "equipment", "rt": "route", "db": "deal_breakers",
+    "av": "availability", "vio": "violations", "med": "medical_card",
+    "ref": "references", "pitch": "pitch", "offer": "offer",
+    "np": "negotiate_pay", "nht": "negotiate_home_time",
+    "sb": "signing_bonus", "ac": "address_concern",
+}
+
+def print_obs(obs, reward):
+    print(f"\n{'='*60}")
+    print(f"Driver: {obs['driver_name']}")
+    if obs.get('crm_summary'):
+        print(f"\nCRM:\n{obs['crm_summary']}")
+    if obs.get('jobs_summary'):
+        print(f"\nJobs:\n{obs['jobs_summary']}")
+    if obs.get('discovered_info'):
+        print(f"\nDiscovered:\n{obs['discovered_info']}")
+    status = f"Stage: {obs['stage']}"
+    if obs.get('pending_reply'):
+        status += " | PENDING REPLY"
+    print(f"\n{status}")
+    print(f"Reward this step: {reward}")
+    if obs.get('feedback'):
+        try:
+            fb = json.loads(obs['feedback'])
+            print(f"Response: {json.dumps(fb, indent=2)}")
+        except (json.JSONDecodeError, TypeError):
+            print(f"Response: {obs['feedback']}")
+
+def print_help():
+    print("\nShortcuts:")
+    print("  r     = read CRM")
+    print("  rr    = read reply")
+    print("  w     = wait")
+    print("  ca    = check approval")
+    print("  hi    = update stage to hired")
+    print("  lost  = update stage to lost")
+    print("\nSend message:  s <topic>     e.g. s g, s exp, s offer")
+    print("  Topics: g=greeting c=call exp=experience ht=home_time pay eq=equipment")
+    print("  rt=route db=deal_breakers av=availability vio=violations med=medical_card")
+    print("  ref=references pitch offer np=negotiate_pay nht=negotiate_home_time")
+    print("  sb=signing_bonus ac=address_concern")
+    print("\nWith job_id:   s pitch 2     s offer 3")
+    print("\nUpdate stage:  st <stage>    e.g. st contacted")
+    print("Update field:  f <field> <value>  e.g. f cdl_class A")
+    print("Add note:      n <text>      e.g. n Driver prefers OTR")
+    print("Request approval: ra <job_id> e.g. ra 2")
+    print("\nOr paste raw JSON: {\"tool\":\"crm\",\"action\":\"read_candidate\"}")
+    print("  q = quit, h = help, reset = new episode")
+
+def parse_input(user_input):
+    user_input = user_input.strip()
+    if not user_input:
+        return None
+
+    # Shortcuts
+    if user_input in SHORTCUTS:
+        return json.loads(SHORTCUTS[user_input])
+
+    # Raw JSON
+    if user_input.startswith("{"):
+        return json.loads(user_input)
+
+    parts = user_input.split(None, 2)
+    cmd = parts[0]
+
+    # Send message: s <topic> [job_id]
+    if cmd == "s" and len(parts) >= 2:
+        topic = TOPIC_SHORTCUTS.get(parts[1], parts[1])
+        action = {"tool": "messaging", "action": "send_message", "topic": topic}
+        if len(parts) >= 3:
+            action["job_id"] = int(parts[2])
+        return action
+
+    # Update stage: st <stage>
+    if cmd == "st" and len(parts) >= 2:
+        return {"tool": "crm", "action": "update_stage", "stage": parts[1]}
+
+    # Update field: f <field> <value>
+    if cmd == "f" and len(parts) >= 3:
+        return {"tool": "crm", "action": "update_field", "field": parts[1], "value": parts[2]}
+
+    # Add note: n <text>
+    if cmd == "n" and len(parts) >= 2:
+        return {"tool": "crm", "action": "add_note", "value": " ".join(parts[1:])}
+
+    # Request approval: ra <job_id>
+    if cmd == "ra" and len(parts) >= 2:
+        return {"tool": "approval", "action": "request_approval", "job_id": int(parts[1])}
+
+    print(f"Unknown command: {user_input}. Type 'h' for help.")
+    return None
+
+def main():
+    session = requests.Session()
+    total_reward = 0.0
+
+    print("\n🚛 DRIVER RECRUITING ENVIRONMENT — INTERACTIVE MODE")
+    print_help()
+
+    # Reset
+    resp = session.post(f"{BASE_URL}/reset", json={})
+    data = resp.json()
+    obs = data["observation"]
+    print_obs(obs, 0)
+
+    while True:
+        try:
+            user_input = input("\n> ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print("\nBye!")
+            break
+
+        if user_input == "q":
+            break
+        if user_input == "h":
+            print_help()
+            continue
+        if user_input == "reset":
+            resp = session.post(f"{BASE_URL}/reset", json={})
+            data = resp.json()
+            obs = data["observation"]
+            total_reward = 0.0
+            print_obs(obs, 0)
+            continue
+
+        action = parse_input(user_input)
+        if action is None:
+            continue
+
+        print(f"→ {action['tool']}.{action['action']}"
+              + (f"({action.get('topic', '')})" if action.get('topic') else "")
+              + (f"[job={action['job_id']}]" if action.get('job_id', -1) >= 0 else "")
+              + (f"({action.get('stage', '')})" if action.get('stage') else "")
+              + (f"({action.get('field', '')}={action.get('value', '')})" if action.get('field') else ""))
+
+        resp = session.post(f"{BASE_URL}/step", json=action)
+        data = resp.json()
+        obs = data["observation"]
+        reward = data["reward"]
+        done = data["done"]
+        total_reward += reward
+
+        print_obs(obs, reward)
+        print(f"Total reward: {total_reward:.1f}")
+
+        if done:
+            print(f"\n{'='*60}")
+            print(f"EPISODE OVER — Final stage: {obs['stage']} | Total reward: {total_reward:.1f}")
+            print(f"{'='*60}")
+            print("Type 'reset' for a new episode or 'q' to quit.")
+
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -0,0 +1,45 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-recruitopenenv"
+version = "0.1.0"
+description = "Recruitopenenv environment for OpenEnv"
+requires-python = ">=3.10"
+dependencies = [
+    # Core OpenEnv runtime (provides FastAPI server + HTTP client types)
+    # install from github
+    # "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git",
+    "openenv-core[core]==0.2.1",
+    # Environment-specific dependencies
+    # Add all dependencies needed for your environment here
+    # Examples:
+    # "numpy>=1.19.0",
+    # "torch>=2.0.0",
+    # "gymnasium>=0.29.0",
+    # "openspiel>=1.0.0",
+    # "smolagents>=1.22.0,<2",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.scripts]
+# Server entry point - enables running via: uv run --project . server
+# or: python -m recruitopenenv.server.app
+server = "recruitopenenv.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["recruitopenenv", "recruitopenenv.server"]
+package-dir = { "recruitopenenv" = ".", "recruitopenenv.server" = "server" }

server/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Recruitopenenv environment server components."""
+
+from .recruitopenenv_environment import RecruitopenenvEnvironment
+
+__all__ = ["RecruitopenenvEnvironment"]

server/app.py

@@ -0,0 +1,102 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+FastAPI application for the Recruitopenenv Environment.
+
+This module creates an HTTP server that exposes the RecruitopenenvEnvironment
+over HTTP and WebSocket endpoints, compatible with EnvClient.
+
+Endpoints:
+    - POST /reset: Reset the environment
+    - POST /step: Execute an action
+    - GET /state: Get current environment state
+    - GET /schema: Get action/observation schemas
+    - WS /ws: WebSocket endpoint for persistent sessions
+
+Usage:
+    # Development (with auto-reload):
+    uvicorn server.app:app --reload --host 0.0.0.0 --port 8000
+
+    # Production:
+    uvicorn server.app:app --host 0.0.0.0 --port 8000 --workers 4
+
+    # Or run directly:
+    python -m server.app
+"""
+
+import os
+
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+
+try:
+    from openenv.core.env_server.http_server import create_app
+except Exception as e:  # pragma: no cover
+    raise ImportError(
+        "openenv is required for the web interface. Install dependencies with '\n    uv sync\n'"
+    ) from e
+
+# Import from local models.py (PYTHONPATH includes /app/env in Docker)
+from models import RecruitopenenvAction, RecruitopenenvObservation
+from .recruitopenenv_environment import RecruitopenenvEnvironment
+
+
+# Create the app with web interface and README integration
+app = create_app(
+    RecruitopenenvEnvironment,
+    RecruitopenenvAction,
+    RecruitopenenvObservation,
+    env_name="recruitopenenv",
+    max_concurrent_envs=1,  # increase this number to allow more concurrent WebSocket sessions
+)
+
+# CORS for demo page
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Serve the demo page
+_DEMO_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "demo")
+
+
+@app.get("/demo", include_in_schema=False)
+async def demo_page():
+    return FileResponse(os.path.join(_DEMO_DIR, "index.html"))
+
+
+def main(host: str = "0.0.0.0", port: int = 8000):
+    """
+    Entry point for direct execution via uv run or python -m.
+
+    This function enables running the server without Docker:
+        uv run --project . server
+        uv run --project . server --port 8001
+        python -m recruitopenenv.server.app
+
+    Args:
+        host: Host address to bind to (default: "0.0.0.0")
+        port: Port number to listen on (default: 8000)
+
+    For production deployments, consider using uvicorn directly with
+    multiple workers:
+        uvicorn recruitopenenv.server.app:app --workers 4
+    """
+    import uvicorn
+
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--port", type=int, default=8000)
+    args = parser.parse_args()
+    main(port=args.port)

server/recruitopenenv_environment.py

@@ -0,0 +1,1422 @@
+"""
+Driver Recruit Environment — Tool-based Long-Horizon.
+
+Agent interacts through 4 tools: CRM, messaging, approval, workflow.
+Each recruiting interaction requires multiple tool calls, creating
+naturally long episodes (40-70 steps).
+
+Pipeline: lead → contacted → interested → approval_pending → offer_sent → hired
+Terminal failures: lost, ghosted
+"""
+
+import json
+import random
+from uuid import uuid4
+
+from openenv.core.env_server.interfaces import Environment
+from openenv.core.env_server.types import State
+
+from models import RecruitopenenvAction, RecruitopenenvObservation
+
+# --- Constants ---
+
+FIRST_NAMES = [
+    "Mike", "James", "Robert", "John", "David", "Carlos", "Marcus",
+    "Sarah", "Maria", "Linda", "Patricia", "Jessica", "Angela", "Rosa",
+    "Travis", "Derek", "Kevin", "Brandon", "Tyler", "Dustin", "Ray",
+]
+LAST_NAMES = [
+    "Johnson", "Smith", "Williams", "Garcia", "Martinez", "Brown",
+    "Davis", "Rodriguez", "Wilson", "Taylor", "Thomas", "Moore",
+    "Jackson", "White", "Harris", "Clark", "Lewis", "Young",
+]
+LOCATIONS = [
+    "Dallas TX", "Atlanta GA", "Chicago IL", "Denver CO", "Phoenix AZ",
+    "Memphis TN", "Louisville KY", "Nashville TN", "Indianapolis IN",
+    "Columbus OH", "Jacksonville FL", "Charlotte NC", "Kansas City MO",
+]
+COMPANIES = [
+    "Werner Enterprises", "Swift Transport", "Schneider National",
+    "J.B. Hunt", "KLLM Transport", "Heartland Express",
+    "Covenant Logistics", "USA Truck", "Marten Transport",
+    "Prime Inc", "CR England", "Western Express",
+]
+
+CDL_CLASSES = ["A", "B"]
+ENDORSEMENTS_ALL = ["H", "N", "T", "TWIC"]
+HOME_TIMES = ["daily", "weekends", "weekly", "biweekly"]
+ROUTE_TYPES = ["OTR", "regional", "local", "dedicated"]
+EQUIPMENT_TYPES = ["dry_van", "flatbed", "reefer", "tanker"]
+CONTACT_METHODS = ["text", "call"]
+DEAL_BREAKERS_ALL = [
+    "touch_freight", "forced_dispatch", "team_driving",
+    "northeast", "hazmat_no_premium", "no_benefits",
+]
+
+PERSONALITY_PARAMS = {
+    "chatty":       {"initial_trust": 0.80, "decay": 0.02, "reveal_breakers": "all"},
+    "professional": {"initial_trust": 0.70, "decay": 0.025, "reveal_breakers": "all"},
+    "impatient":    {"initial_trust": 0.60, "decay": 0.04, "reveal_breakers": "partial"},
+    "suspicious":   {"initial_trust": 0.55, "decay": 0.03, "reveal_breakers": "all_if_trusted"},
+}
+
+AVAILABILITIES = ["immediately", "2_weeks", "1_month", "negotiable"]
+VIOLATION_LEVELS = ["clean", "minor", "major"]
+MEDICAL_CARD_STATUS = ["valid", "expiring_soon", "expired"]
+REFERENCE_QUALITY = ["strong", "mixed", "none"]
+
+MAX_STEPS = 100
+
+VALID_TOOL_ACTIONS = {
+    "crm": {"read_candidate", "update_stage", "update_field", "add_note"},
+    "messaging": {"send_message", "read_reply"},
+    "approval": {"request_approval", "check_approval"},
+    "workflow": {"wait"},
+}
+
+VALID_TOPICS = {
+    "greeting", "call",
+    "experience", "home_time", "pay", "equipment", "route", "deal_breakers",
+    "availability", "violations", "medical_card", "references",
+    "pitch", "offer",
+    "negotiate_pay", "negotiate_home_time", "signing_bonus", "address_concern",
+}
+
+STAGE_ORDER = ["lead", "contacted", "interested", "approval_pending", "offer_sent", "hired"]
+ALL_STAGES = set(STAGE_ORDER) | {"lost", "ghosted"}
+
+SCREENING_TOPICS = {
+    "experience", "home_time", "pay", "equipment", "route", "deal_breakers",
+    "availability", "violations", "medical_card", "references",
+}
+
+VALID_CRM_FIELDS = {
+    "cdl_class", "years_experience", "endorsements", "location",
+    "home_time_pref", "pay_expectation", "equipment_pref", "route_pref",
+    "deal_breakers", "availability", "violations", "medical_card", "references",
+    "matched_job",
+}
+
+
+# --- Data generation ---
+
+
+def generate_driver():
+    personality = random.choices(
+        ["chatty", "professional", "impatient", "suspicious"],
+        weights=[25, 35, 20, 20],
+    )[0]
+    params = PERSONALITY_PARAMS[personality]
+
+    cdl = random.choices(CDL_CLASSES, weights=[75, 25])[0]
+    exp = random.randint(1, 20)
+
+    endorsements = [e for e in ENDORSEMENTS_ALL if random.random() < 0.10 + exp * 0.02]
+
+    equip_opts = ["dry_van", "flatbed", "reefer"]
+    if "N" in endorsements:
+        equip_opts.append("tanker")
+    equipment_pref = random.choice(equip_opts)
+
+    n_breakers = random.choices([1, 2, 3], weights=[30, 50, 20])[0]
+    deal_breakers = random.sample(DEAL_BREAKERS_ALL, n_breakers)
+
+    return {
+        "name": f"{random.choice(FIRST_NAMES)} {random.choice(LAST_NAMES)}",
+        "cdl_class": cdl,
+        "endorsements": endorsements,
+        "experience_years": exp,
+        "location": random.choice(LOCATIONS),
+        "preferred_contact": random.choice(CONTACT_METHODS),
+        "personality": personality,
+        "trust": params["initial_trust"],
+        "decay": params["decay"],
+        "home_time_pref": random.choices(HOME_TIMES, weights=[15, 30, 30, 25])[0],
+        "min_cpm": round(random.uniform(0.48, 0.78), 2),
+        "equipment_pref": equipment_pref,
+        "route_pref": random.choices(ROUTE_TYPES, weights=[20, 30, 30, 20])[0],
+        "deal_breakers": deal_breakers,
+        "availability": random.choices(AVAILABILITIES, weights=[30, 35, 25, 10])[0],
+        "violations": random.choices(VIOLATION_LEVELS, weights=[60, 30, 10])[0],
+        "medical_card": random.choices(MEDICAL_CARD_STATUS, weights=[70, 20, 10])[0],
+        "references": random.choices(REFERENCE_QUALITY, weights=[40, 40, 20])[0],
+    }
+
+
+def generate_jobs(driver):
+    """Generate 6 jobs: 1-2 good, 1-2 traps, 2-3 bad."""
+    jobs = []
+    if random.random() > 0.2:
+        jobs.append(_make_good_job(driver, 0))
+    else:
+        jobs.append(_make_trap_job(driver, 0))
+    jobs.append(_make_trap_job(driver, 1))
+    jobs.append(_make_partial_job(driver, 2))
+
+    bad_cdl = "B" if driver["cdl_class"] == "A" else "A"
+    jobs.append({
+        "job_id": 3, "company": random.choice(COMPANIES),
+        "required_cdl": bad_cdl, "required_endorsements": [],
+        "min_experience": random.randint(1, 5),
+        "route_type": random.choice(ROUTE_TYPES),
+        "home_time": random.choice(HOME_TIMES),
+        "pay_cpm": round(random.uniform(0.50, 0.85), 2),
+        "equipment": random.choice(EQUIPMENT_TYPES),
+        "has_touch_freight": random.random() < 0.3,
+        "forced_dispatch": random.random() < 0.3,
+        "team_driving": False, "northeast_routes": False,
+        "hazmat_premium": False,
+        "benefits": random.choice(["none", "basic", "good"]),
+        "location": random.choice(LOCATIONS),
+        "start_urgency": random.choice(["immediate", "flexible"]),
+        "requires_clean_record": random.random() < 0.3,
+        "requires_medical": True,
+    })
+
+    jobs.append({
+        "job_id": 4, "company": random.choice(COMPANIES),
+        "required_cdl": driver["cdl_class"],
+        "required_endorsements": ["H", "T"],
+        "min_experience": driver["experience_years"] + random.randint(5, 10),
+        "route_type": random.choice(ROUTE_TYPES),
+        "home_time": random.choice(HOME_TIMES),
+        "pay_cpm": round(random.uniform(0.70, 0.90), 2),
+        "equipment": random.choice(EQUIPMENT_TYPES),
+        "has_touch_freight": False, "forced_dispatch": False,
+        "team_driving": False, "northeast_routes": False,
+        "hazmat_premium": True, "benefits": "excellent",
+        "location": random.choice(LOCATIONS),
+        "start_urgency": "flexible",
+        "requires_clean_record": True,
+        "requires_medical": True,
+    })
+
+    if random.random() < 0.5:
+        jobs.append(_make_trap_job(driver, 5))
+    else:
+        jobs.append({
+            "job_id": 5, "company": random.choice(COMPANIES),
+            "required_cdl": bad_cdl, "required_endorsements": [],
+            "min_experience": random.randint(1, 8),
+            "route_type": random.choice(ROUTE_TYPES),
+            "home_time": driver["home_time_pref"],
+            "pay_cpm": round(driver["min_cpm"] + random.uniform(0.05, 0.15), 2),
+            "equipment": driver["equipment_pref"],
+            "has_touch_freight": False, "forced_dispatch": False,
+            "team_driving": False, "northeast_routes": False,
+            "hazmat_premium": False, "benefits": "good",
+            "location": random.choice(LOCATIONS),
+            "start_urgency": random.choice(["immediate", "flexible"]),
+            "requires_clean_record": random.random() < 0.3,
+            "requires_medical": True,
+        })
+
+    random.shuffle(jobs)
+    for i, j in enumerate(jobs):
+        j["job_id"] = i
+    return jobs
+
+
+def _make_good_job(driver, job_id):
+    return {
+        "job_id": job_id, "company": random.choice(COMPANIES),
+        "required_cdl": driver["cdl_class"],
+        "required_endorsements": [e for e in driver["endorsements"] if random.random() < 0.3],
+        "min_experience": max(1, driver["experience_years"] - random.randint(1, 3)),
+        "route_type": driver["route_pref"],
+        "home_time": driver["home_time_pref"],
+        "pay_cpm": round(driver["min_cpm"] + random.uniform(0.03, 0.12), 2),
+        "equipment": driver["equipment_pref"],
+        "has_touch_freight": False, "forced_dispatch": False,
+        "team_driving": False, "northeast_routes": False,
+        "hazmat_premium": "H" in driver.get("endorsements", []),
+        "benefits": random.choice(["good", "excellent"]),
+        "location": random.choice(LOCATIONS),
+        "start_urgency": random.choice(["immediate", "flexible"]),
+        "requires_clean_record": random.random() < 0.3,
+        "requires_medical": True,
+    }
+
+
+def _make_trap_job(driver, job_id):
+    trap = _make_good_job(driver, job_id)
+    breaker = random.choice(driver["deal_breakers"])
+    if breaker == "touch_freight":
+        trap["has_touch_freight"] = True
+    elif breaker == "forced_dispatch":
+        trap["forced_dispatch"] = True
+    elif breaker == "team_driving":
+        trap["team_driving"] = True
+    elif breaker == "northeast":
+        trap["northeast_routes"] = True
+    elif breaker == "hazmat_no_premium":
+        trap["required_endorsements"] = ["H"]
+        trap["hazmat_premium"] = False
+    elif breaker == "no_benefits":
+        trap["benefits"] = "none"
+    return trap
+
+
+def _make_partial_job(driver, job_id):
+    job = _make_good_job(driver, job_id)
+    if random.random() < 0.5:
+        job["pay_cpm"] = round(driver["min_cpm"] - random.uniform(0.01, 0.06), 2)
+    else:
+        others = [h for h in HOME_TIMES if h != driver["home_time_pref"]]
+        job["home_time"] = random.choice(others)
+    return job
+
+
+def format_jobs(jobs):
+    lines = []
+    for j in jobs:
+        endorse = ", ".join(j["required_endorsements"]) if j["required_endorsements"] else "none"
+        flags = []
+        if j["has_touch_freight"]:
+            flags.append("touch freight")
+        if j["forced_dispatch"]:
+            flags.append("forced dispatch")
+        if j["team_driving"]:
+            flags.append("team driving")
+        if j["northeast_routes"]:
+            flags.append("northeast routes")
+        flag_str = f" [{', '.join(flags)}]" if flags else ""
+        urgency = j.get("start_urgency", "flexible")
+        clean = "clean record required" if j.get("requires_clean_record") else ""
+        medical = "DOT medical required" if j.get("requires_medical") else ""
+        reqs = ", ".join(filter(None, [clean, medical]))
+        req_str = f" ({reqs})" if reqs else ""
+        lines.append(
+            f"Job {j['job_id']}: {j['company']} — CDL-{j['required_cdl']}, "
+            f"{j['min_experience']}+ yrs, {j['route_type']}, "
+            f"${j['pay_cpm']}/mi, {j['home_time']} home, "
+            f"{j['equipment']}, endorsements: {endorse}, "
+            f"benefits: {j['benefits']}, start: {urgency}{req_str}{flag_str}"
+        )
+    return "\n".join(lines)
+
+
+def trust_label(trust):
+    if trust >= 0.7:
+        return "high"
+    elif trust >= 0.4:
+        return "medium"
+    return "low"
+
+
+# --- Job fit scoring ---
+
+
+def score_job_fit(driver, job):
+    """Returns (score 0-100, issues list, fatal bool)."""
+    score = 100
+    issues = []
+
+    if driver["cdl_class"] != job["required_cdl"]:
+        return 0, ["CDL class mismatch"], True
+    if driver["experience_years"] < job["min_experience"]:
+        return 0, [f"Needs {job['min_experience']} yrs, driver has {driver['experience_years']}"], True
+    for e in job["required_endorsements"]:
+        if e not in driver["endorsements"]:
+            return 0, [f"Missing {e} endorsement"], True
+
+    if job["has_touch_freight"] and "touch_freight" in driver["deal_breakers"]:
+        return 0, ["Touch freight is a deal breaker"], True
+    if job["forced_dispatch"] and "forced_dispatch" in driver["deal_breakers"]:
+        return 0, ["Forced dispatch is a deal breaker"], True
+    if job["team_driving"] and "team_driving" in driver["deal_breakers"]:
+        return 0, ["Team driving is a deal breaker"], True
+    if job["northeast_routes"] and "northeast" in driver["deal_breakers"]:
+        return 0, ["Northeast routes is a deal breaker"], True
+    if ("H" in job["required_endorsements"] and not job["hazmat_premium"]
+            and "hazmat_no_premium" in driver["deal_breakers"]):
+        return 0, ["Hazmat without premium pay"], True
+    if job["benefits"] == "none" and "no_benefits" in driver["deal_breakers"]:
+        return 0, ["No benefits is a deal breaker"], True
+
+    if job["pay_cpm"] < driver["min_cpm"]:
+        diff = driver["min_cpm"] - job["pay_cpm"]
+        if diff > 0.10:
+            return 0, [f"Pay ${job['pay_cpm']}/mi way below min ${driver['min_cpm']}/mi"], True
+        score -= int(diff * 400)
+        issues.append(f"Pay is ${diff:.2f}/mi below minimum")
+
+    if job["home_time"] != driver["home_time_pref"]:
+        score -= 25
+        issues.append(f"Home time: job={job['home_time']}, wants={driver['home_time_pref']}")
+
+    if job["route_type"] != driver["route_pref"]:
+        score -= 15
+        issues.append(f"Route: job={job['route_type']}, wants={driver['route_pref']}")
+
+    if job["equipment"] != driver["equipment_pref"]:
+        score -= 10
+        issues.append(f"Equipment: job={job['equipment']}, prefers={driver['equipment_pref']}")
+
+    if job.get("requires_clean_record") and driver.get("violations") == "major":
+        return 0, ["Major violations disqualify for this position"], True
+    if job.get("requires_medical") and driver.get("medical_card") == "expired":
+        return 0, ["Expired DOT medical card"], True
+
+    if job.get("requires_clean_record") and driver.get("violations") == "minor":
+        score -= 15
+        issues.append("Minor violations may be a concern for clean-record position")
+    if driver.get("medical_card") == "expiring_soon":
+        score -= 5
+        issues.append("DOT medical card expiring soon, needs renewal")
+    if job.get("start_urgency") == "immediate" and driver.get("availability") == "1_month":
+        score -= 20
+        issues.append("Driver can't start for a month, job needs immediate start")
+    if driver.get("references") == "none":
+        score -= 10
+        issues.append("No references available")
+    elif driver.get("references") == "mixed":
+        score -= 5
+        issues.append("Mixed references from previous employers")
+
+    return max(0, score), issues, False
+
+
+# --- Natural language response templates ---
+
+
+def _respond_experience(driver):
+    p = driver["personality"]
+    cdl = driver["cdl_class"]
+    yrs = driver["experience_years"]
+    endorse = driver["endorsements"]
+    loc = driver["location"]
+    endorse_str = ", ".join(endorse) if endorse else "none"
+
+    if p == "chatty":
+        return (
+            f"Oh yeah, I've been driving for {yrs} years now! Got my CDL-{cdl} "
+            f"right out of school. "
+            f"{'I picked up my ' + endorse_str + ' endorsements along the way.' if endorse else 'No special endorsements yet but been thinking about it.'} "
+            f"Based out of {loc}, been here my whole life."
+        )
+    elif p == "impatient":
+        return f"CDL-{cdl}, {yrs} years. Endorsements: {endorse_str}. {loc}."
+    elif p == "suspicious":
+        if driver["trust"] < 0.5:
+            return f"I've got a CDL-{cdl}. Been driving a while, out of {loc}."
+        return f"CDL-{cdl}, {yrs} years experience. Endorsements: {endorse_str}. Based in {loc}."
+    else:
+        return (
+            f"I hold a CDL-{cdl} with {yrs} years of commercial driving experience. "
+            f"Endorsements: {endorse_str}. I'm located in {loc}."
+        )
+
+
+def _respond_home_time(driver):
+    p = driver["personality"]
+    pref = driver["home_time_pref"]
+    templates = {
+        "chatty": {
+            "daily": "Oh yeah, I gotta be home every night. My wife would kill me otherwise! We got three kids and I help with homework every evening.",
+            "weekends": "I need my weekends, you know? My kids have soccer on Saturdays and church on Sundays. Weekday runs are fine though.",
+            "weekly": "I like to be home at least once a week. I can do a few days out but need to get back regularly.",
+            "biweekly": "I can do longer runs, two weeks out is fine. My buddy and I go fishing every other weekend so that works out.",
+        },
+        "impatient": {
+            "daily": "Home daily. Non-negotiable.",
+            "weekends": "Home on weekends.",
+            "weekly": "Home weekly.",
+            "biweekly": "Two weeks out is fine.",
+        },
+        "suspicious": {
+            "daily": "I need to be home... regularly." if driver["trust"] < 0.5 else "I need to be home every night, that's firm.",
+            "weekends": "I need my time off." if driver["trust"] < 0.5 else "I need to be home on weekends for my family.",
+            "weekly": "Can't be gone too long." if driver["trust"] < 0.5 else "I need to get home at least once a week.",
+            "biweekly": "I'm flexible on time out." if driver["trust"] < 0.5 else "Two weeks out, two days home works for me.",
+        },
+        "professional": {
+            "daily": "I'm looking for local routes that get me home every evening.",
+            "weekends": "I'd like to be home on weekends. Weekday runs are fine.",
+            "weekly": "I prefer weekly home time. A few days out, then home for a reset.",
+            "biweekly": "I'm comfortable with biweekly home time. I've done OTR for years.",
+        },
+    }
+    return templates[p][pref]
+
+
+def _respond_pay(driver):
+    p = driver["personality"]
+    cpm = driver["min_cpm"]
+    if p == "chatty":
+        return f"I'm making ${cpm}/mile right now and honestly I won't move for less. If you can beat that by a few cents and throw in a decent sign-on bonus, I'm listening."
+    elif p == "impatient":
+        return f"${cpm}/mile minimum. Don't lowball me."
+    elif p == "suspicious":
+        if driver["trust"] < 0.5:
+            return "I need to be paid fair, you know what I'm saying? What are you offering?"
+        return f"Look, I need at least ${cpm}/mile. I know what I'm worth."
+    else:
+        return f"My minimum is ${cpm} per mile. I'm open to discussing total compensation including benefits."
+
+
+def _respond_equipment(driver):
+    p = driver["personality"]
+    pref = driver["equipment_pref"]
+    pretty = pref.replace("_", " ")
+    if p == "chatty":
+        extra = " Got my tanker endorsement too so I can do that." if "N" in driver["endorsements"] else ""
+        return f"I've been running {pretty} mostly. Love it, got the hang of it.{extra} Wouldn't mind sticking with what I know."
+    elif p == "impatient":
+        return f"{pretty.title()}. That's what I run."
+    elif p == "suspicious":
+        if driver["trust"] < 0.5:
+            return "I've got experience with different trailers."
+        return f"I prefer {pretty}. That's where most of my experience is."
+    else:
+        return f"My primary experience is with {pretty} equipment. I'd prefer to stay in that lane."
+
+
+def _respond_route(driver):
+    p = driver["personality"]
+    pref = driver["route_pref"]
+    routes = {
+        "chatty": {
+            "OTR": "I like the open road, OTR is my thing. See the country, you know?",
+            "regional": "Regional is my sweet spot. Good miles but still get home.",
+            "local": "Local runs for me. I know every road in this city!",
+            "dedicated": "Dedicated routes are great. Same customer, same lanes, no surprises.",
+        },
+        "impatient": {"OTR": "OTR.", "regional": "Regional.", "local": "Local.", "dedicated": "Dedicated."},
+        "suspicious": {
+            "OTR": ("Depends on the route." if driver["trust"] < 0.5 else "I'm looking for OTR work."),
+            "regional": ("Depends on the area." if driver["trust"] < 0.5 else "I'm looking for regional work."),
+            "local": ("I want to stay close to home." if driver["trust"] < 0.5 else "Local is what I want."),
+            "dedicated": ("Depends on the lanes." if driver["trust"] < 0.5 else "I prefer dedicated routes."),
+        },
+        "professional": {
+            "OTR": "I'm interested in OTR positions.",
+            "regional": "I'm looking for regional opportunities.",
+            "local": "I'd prefer local routes.",
+            "dedicated": "Dedicated lanes would be ideal.",
+        },
+    }
+    return routes[p][pref]
+
+
+def _respond_deal_breakers(driver):
+    p = driver["personality"]
+    breakers = driver["deal_breakers"]
+    labels = {
+        "touch_freight": "touch freight",
+        "forced_dispatch": "forced dispatch",
+        "team_driving": "team driving",
+        "northeast": "northeast/NYC routes",
+        "hazmat_no_premium": "hazmat without extra pay",
+        "no_benefits": "no health benefits",
+    }
+    if p == "chatty":
+        items = [labels[b] for b in breakers]
+        return f"Oh man, don't even get me started. I will NOT do {', '.join(items)}. Had bad experiences with all of that."
+    elif p == "impatient":
+        return f"No {labels[breakers[0]]}. That's my line."
+    elif p == "suspicious":
+        if driver["trust"] < 0.5:
+            return "I've got my limits. What kind of freight are we talking about?"
+        items = [labels[b] for b in breakers]
+        return f"I won't do {', '.join(items)}. Those are hard stops for me."
+    else:
+        items = [labels[b] for b in breakers]
+        return f"My non-negotiables: no {', no '.join(items)}."
+
+
+def _respond_availability(driver):
+    p = driver["personality"]
+    avail = driver["availability"]
+    labels = {"immediately": "right away", "2_weeks": "in about two weeks", "1_month": "in about a month", "negotiable": "depends on the offer"}
+    if p == "chatty":
+        if avail == "immediately":
+            return "I'm ready to go! Just left my last company, sitting at home going crazy. Can start tomorrow if you need me."
+        elif avail == "2_weeks":
+            return "I need to give my current place two weeks notice. They've been good to me, wanna leave right."
+        elif avail == "1_month":
+            return "It'll be about a month. I'm finishing up a contract and need to wrap some things up at home too."
+        else:
+            return "Depends on what you've got. For the right job I could move quick, otherwise I'm okay where I am."
+    elif p == "impatient":
+        return f"Can start {labels[avail]}."
+    elif p == "suspicious":
+        if driver["trust"] < 0.5:
+            return "Why do you need to know that already? I'll be available when I'm available."
+        return f"I can start {labels[avail]}."
+    else:
+        return f"I'm available to start {labels[avail]}. I can be flexible depending on the opportunity."
+
+
+def _respond_violations(driver):
+    p = driver["personality"]
+    violations = driver["violations"]
+    if p == "chatty":
+        if violations == "clean":
+            return "Clean record, twenty years no accidents! Well, one close call in '09 but that wasn't my fault. Nothing on the record though."
+        elif violations == "minor":
+            return "I had a minor thing a while back, nothing serious. A speeding ticket in a construction zone. Learned my lesson."
+        else:
+            return "Look, I had an incident a few years ago. It was a bad situation but I've cleaned up since then. I'm a different driver now."
+    elif p == "impatient":
+        if violations == "clean":
+            return "Clean record."
+        elif violations == "minor":
+            return "Minor stuff, nothing serious."
+        else:
+            return "I've had some issues. It's in the past."
+    elif p == "suspicious":
+        if driver["trust"] < 0.5:
+            return "Why are you asking about that? My record is my business."
+        if violations == "clean":
+            return "My record is clean. You can check."
+        elif violations == "minor":
+            return "There's a minor thing on there but nothing that should matter."
+        else:
+            return "I've had some trouble before. But I've been clean for two years now."
+    else:
+        if violations == "clean":
+            return "I have a clean driving record with no violations or incidents."
+        elif violations == "minor":
+            return "I have a minor violation on record. I'm happy to discuss the details."
+        else:
+            return "I do have a violation on my record. I've taken corrective steps since then."
+
+
+def _respond_medical_card(driver):
+    p = driver["personality"]
+    status = driver["medical_card"]
+    if p == "chatty":
+        if status == "valid":
+            return "Yep, DOT medical is all good! Just renewed it last month actually. Passed with flying colors."
+        elif status == "expiring_soon":
+            return "Oh yeah, I need to renew that soon actually. Thanks for reminding me. It's coming up in a few weeks."
+        else:
+            return "Ugh, yeah, it expired. I've been meaning to get that renewed. Can I still apply while I'm working on it?"
+    elif p == "impatient":
+        if status == "valid":
+            return "DOT medical is current."
+        elif status == "expiring_soon":
+            return "Expires soon. I'll renew it."
+        else:
+            return "It's expired. I'll get it done."
+    elif p == "suspicious":
+        if driver["trust"] < 0.5:
+            return "My medical stuff is between me and my doctor."
+        if status == "valid":
+            return "My DOT medical is current and valid."
+        elif status == "expiring_soon":
+            return "It's expiring soon but I've got an appointment scheduled."
+        else:
+            return "It lapsed. I can get it renewed if there's a real opportunity here."
+    else:
+        if status == "valid":
+            return "My DOT medical certificate is current and valid."
+        elif status == "expiring_soon":
+            return "My medical card is expiring soon. I plan to renew it promptly."
+        else:
+            return "My DOT medical has expired. I'm prepared to renew it for the right position."
+
+
+def _respond_references(driver):
+    p = driver["personality"]
+    refs = driver["references"]
+    if p == "chatty":
+        if refs == "strong":
+            return "Oh yeah, my last dispatcher loved me! You can call anyone I've worked for. They'll all say good things."
+        elif refs == "mixed":
+            return "Most of my old bosses would say good things... I had a rough patch at one place but we parted okay."
+        else:
+            return "I've mostly done owner-operator stuff, so I don't really have traditional references. But I can show you my load history!"
+    elif p == "impatient":
+        if refs == "strong":
+            return "References are solid. Call whoever you want."
+        elif refs == "mixed":
+            return "Some are better than others."
+        else:
+            return "Don't have references. I work for myself."
+    elif p == "suspicious":
+        if driver["trust"] < 0.5:
+            return "I'm not giving you names until I know this is serious."
+        if refs == "strong":
+            return "I've got good references. I'll provide them when we're further along."
+        elif refs == "mixed":
+            return "I have some references. It depends on who you talk to."
+        else:
+            return "I don't have traditional references."
+    else:
+        if refs == "strong":
+            return "I have strong references from my previous employers. Happy to provide contact information."
+        elif refs == "mixed":
+            return "I can provide references. My track record has been generally positive."
+        else:
+            return "I don't have employer references available, though I can provide other professional contacts."
+
+
+def _respond_pitch(driver, job):
+    score, issues, fatal = score_job_fit(driver, job)
+    if fatal:
+        reason = issues[0] if issues else "not a fit"
+        p = driver["personality"]
+        if p == "chatty":
+            return f"Nah, that's not gonna work for me. {reason}. Got anything else?"
+        elif p == "impatient":
+            return f"No. {reason}."
+        elif p == "suspicious":
+            return f"Why would you pitch me that? {reason}."
+        else:
+            return f"I'll have to pass. {reason}."
+    elif score >= 80:
+        p = driver["personality"]
+        if p == "chatty":
+            return "Now THAT sounds interesting! The pay is right, the home time works... I could see myself there."
+        elif p == "impatient":
+            return "That could work. What's next?"
+        elif p == "suspicious":
+            return "Hmm, that actually doesn't sound bad. What's the catch?"
+        else:
+            return "That aligns well with what I'm looking for. I'd like to move forward."
+    else:
+        concern = issues[0] if issues else "something's off"
+        p = driver["personality"]
+        if p == "chatty":
+            return f"It's close but I'm not sure... {concern}. Maybe if they could adjust something?"
+        elif p == "impatient":
+            return f"Ehh. {concern}."
+        elif p == "suspicious":
+            return f"I don't know... {concern}. What else you got?"
+        else:
+            return f"It's interesting but I have a concern: {concern}."
+
+
+# --- Contact response templates ---
+
+
+def _respond_contact_good(driver, topic):
+    p = driver["personality"]
+    method = "text" if topic == "greeting" else "call"
+    if p == "chatty":
+        if method == "text":
+            return "Hey! Yeah I got your text. I've been looking for something new actually. What do you have for me?"
+        return "Hello? Oh hey, yeah I was hoping someone would reach out. I'm definitely interested in hearing about opportunities."
+    elif p == "impatient":
+        if method == "text":
+            return "Got your text. What do you have?"
+        return "Yeah, I'm listening. What's the job?"
+    elif p == "suspicious":
+        if method == "text":
+            return "Hey. How'd you get my number? ...Okay, I'm listening I guess."
+        return "Who is this? ...A recruiter? Alright, what are you offering?"
+    else:
+        if method == "text":
+            return "Thanks for reaching out. I'm open to new opportunities. What positions do you have available?"
+        return "Hello, thanks for the call. I'm currently exploring new opportunities. What do you have?"
+
+
+def _respond_contact_wrong(driver, topic):
+    p = driver["personality"]
+    if topic == "greeting":  # texted a caller
+        if p == "chatty":
+            return "Oh hey, got your text. I usually prefer a phone call but no worries, what's up?"
+        elif p == "impatient":
+            return "Text is fine I guess. What do you want?"
+        elif p == "suspicious":
+            return "...Who is this? I don't usually respond to random texts."
+        else:
+            return "I received your message. I generally prefer a phone call, but I'm happy to chat."
+    else:  # called a texter
+        if p == "chatty":
+            return "Oh, uh, hey. I wasn't expecting a call. I'm kinda busy, could you text me instead? ...Fine, what is it?"
+        elif p == "impatient":
+            return "I don't pick up unknown numbers usually. Should've texted. What do you want?"
+        elif p == "suspicious":
+            return "Who is this? I don't answer calls from numbers I don't know."
+        else:
+            return "Hello. I prefer to communicate via text if possible. But go ahead, what do you have?"
+
+
+def _respond_contact_repeat(driver):
+    p = driver["personality"]
+    if p == "chatty":
+        return "You already reached out to me! What else do you need?"
+    elif p == "impatient":
+        return "You already contacted me. What now?"
+    elif p == "suspicious":
+        return "Why are you contacting me again? We already talked."
+    else:
+        return "We've already been in touch. What's the next step?"
+
+
+def _respond_repeat_question(driver, topic):
+    p = driver["personality"]
+    if p == "chatty":
+        return f"Didn't I already tell you about my {topic}? I feel like we covered that!"
+    elif p == "impatient":
+        return f"I already answered that. Pay attention."
+    elif p == "suspicious":
+        return f"You already asked me about {topic}. Why are you asking again?"
+    else:
+        return f"I believe I already shared my {topic} preferences with you."
+
+
+# --- Offer/submit response templates ---
+
+
+def _respond_offer_accept(driver, job):
+    p = driver["personality"]
+    company = job["company"]
+    if p == "chatty":
+        return f"Awesome! {company} sounds great, I'm excited to get started. Thanks for finding this for me!"
+    elif p == "impatient":
+        return f"Good. {company}. When do I start?"
+    elif p == "suspicious":
+        return f"Alright, {company} it is. I hope this works out. Thanks."
+    else:
+        return f"Thank you for the placement at {company}. I'm looking forward to getting started."
+
+
+def _respond_offer_concerns(driver, job, concern):
+    p = driver["personality"]
+    company = job["company"]
+    if p == "chatty":
+        return f"I mean, {company} is okay I guess. {concern} bugs me a little but maybe we can work something out?"
+    elif p == "impatient":
+        return f"Ehh. {concern}. Can you fix that?"
+    elif p == "suspicious":
+        return f"I'm not fully sold on {company}. {concern}. What are you going to do about it?"
+    else:
+        return f"I have a concern about the {company} position: {concern}. Can we discuss?"
+
+
+def _respond_offer_reject(driver, reason):
+    p = driver["personality"]
+    if p == "chatty":
+        return f"Yeah no, I can't do that. {reason}. I thought we talked about this?"
+    elif p == "impatient":
+        return f"No. {reason}. I'm done here."
+    elif p == "suspicious":
+        return f"Are you serious? {reason}. I knew this was a waste of my time."
+    else:
+        return f"I'm going to have to withdraw. {reason}. This isn't what we discussed."
+
+
+def _respond_ghosted(driver):
+    p = driver["personality"]
+    name = driver["name"].split()[0]
+    if p == "chatty":
+        return f"{name} stopped responding to your messages. Last seen: 'idk man this isn't working out...'"
+    elif p == "impatient":
+        return f"{name} blocked your number."
+    elif p == "suspicious":
+        return f"{name} stopped responding. They were never fully comfortable with the process."
+    else:
+        return f"{name} sent a polite message saying they've decided to go with another recruiter."
+
+
+# --- Negotiation helpers ---
+
+
+def _get_negotiation_concerns(driver, job):
+    _, issues, _ = score_job_fit(driver, job)
+    return issues
+
+
+def _respond_negotiation(driver, action, job, concerns):
+    p = driver["personality"]
+
+    if action == "negotiate_pay":
+        if any("pay" in c.lower() for c in concerns):
+            if p == "chatty":
+                return "Well, if you can get them to bump it up a few cents, I'd feel a lot better about this."
+            elif p == "impatient":
+                return "More money would help. Get it done."
+            elif p == "suspicious":
+                return "I'll believe a pay bump when I see it in writing."
+            else:
+                return "I'd appreciate if you could negotiate a higher rate."
+        else:
+            return "Pay isn't really my concern here."
+
+    elif action == "negotiate_home_time":
+        if any("home time" in c.lower() for c in concerns):
+            if p == "chatty":
+                return "Yeah, if they could work with my schedule that would change everything. Talk to them?"
+            elif p == "impatient":
+                return "Fix the home time and we'll talk."
+            elif p == "suspicious":
+                return "They always say they'll adjust the schedule. Will they actually?"
+            else:
+                return "If the home time can be adjusted, I'd be much more interested."
+        else:
+            return "Home time isn't really my issue here."
+
+    elif action == "signing_bonus":
+        if p == "chatty":
+            return "A signing bonus? Hey, that's nice! Doesn't fix everything but it helps."
+        elif p == "impatient":
+            return "Bonus is fine. What about the real issues?"
+        elif p == "suspicious":
+            return "Bonuses are nice but they don't solve long-term problems."
+        else:
+            return "I appreciate the signing bonus offer. It's a positive gesture."
+
+    elif action == "address_concern":
+        if concerns:
+            if p == "chatty":
+                return f"Yeah, my big thing is: {concerns[0]}. If you can work that out, I'm in."
+            elif p == "impatient":
+                return f"{concerns[0]}. Fix it."
+            elif p == "suspicious":
+                if driver["trust"] < 0.4:
+                    return "I've told you my concerns. Are you actually going to do something about them?"
+                return f"Fine, here's what bothers me: {concerns[0]}."
+            else:
+                return f"My primary concern is: {concerns[0]}. I'd need that resolved."
+        else:
+            return "I don't really have any major concerns. I think we're good."
+
+    return "I'm not sure what you mean."
+
+
+# --- CRM formatting ---
+
+
+def _api(code, **kwargs):
+    """Format a JSON API response with status code."""
+    return json.dumps({"code": code, **kwargs})
+
+
+def format_crm(crm):
+    """Format CRM record into readable string."""
+    lines = [f"Name: {crm['name']}", f"Stage: {crm['stage']}"]
+    if crm["fields"]:
+        lines.append("Fields:")
+        for k, v in sorted(crm["fields"].items()):
+            lines.append(f"  {k}: {v}")
+    else:
+        lines.append("Fields: (none recorded)")
+    if crm["notes"]:
+        lines.append("Notes:")
+        for n in crm["notes"]:
+            lines.append(f"  - {n}")
+    return "\n".join(lines)
+
+
+# --- Environment ---
+
+
+class RecruitopenenvEnvironment(Environment):
+    """Driver recruiting environment with tool-based long-horizon interaction."""
+
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
+    def __init__(self):
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        self._driver = {}
+        self._jobs = []
+        # CRM state
+        self._crm = {"name": "", "stage": "lead", "fields": {}, "notes": []}
+        self._has_read_crm = False
+        self._crm_read_count = 0
+        # Messaging state
+        self._pending_reply = None  # (response_text, topic)
+        self._contacted = False
+        self._asked = set()
+        self._discovered_info = []
+        # Approval state
+        self._approval_status = "none"
+        self._approval_job_id = -1
+        # Negotiation state
+        self._matched_job_id = -1
+        self._negotiation_round = 0
+        self._negotiation_score_bonus = 0
+        self._negotiation_concerns = []
+        # Interaction tracking
+        self._last_contact_step = 0
+
+    def _make_obs(self, reward=0.0, done=False, feedback=""):
+        return RecruitopenenvObservation(
+            driver_name=self._driver.get("name", ""),
+            crm_summary=format_crm(self._crm) if self._has_read_crm else "",
+            jobs_summary=format_jobs(self._jobs) if self._jobs else "",
+            discovered_info="\n".join(self._discovered_info),
+            stage=self._crm["stage"],
+            feedback=feedback,
+            pending_reply=self._pending_reply is not None,
+            done=done,
+            reward=reward,
+        )
+
+    def reset(self, seed: int = None) -> RecruitopenenvObservation:
+        if seed is not None:
+            random.seed(seed)
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        self._driver = generate_driver()
+        self._jobs = generate_jobs(self._driver)
+        self._crm = {"name": self._driver["name"], "stage": "lead", "fields": {}, "notes": []}
+        self._has_read_crm = False
+        self._crm_read_count = 0
+        self._pending_reply = None
+        self._contacted = False
+        self._asked = set()
+        self._discovered_info = []
+        self._approval_status = "none"
+        self._approval_job_id = -1
+        self._matched_job_id = -1
+        self._negotiation_round = 0
+        self._negotiation_score_bonus = 0
+        self._negotiation_concerns = []
+        self._last_contact_step = 0
+
+        return self._make_obs(
+            feedback=_api(200, driver=self._driver["name"], jobs=len(self._jobs))
+        )
+
+    def step(self, action: RecruitopenenvAction) -> RecruitopenenvObservation:
+        if not self._driver:
+            return self._make_obs(reward=0.0, done=True, feedback=_api(400, error="no_episode"))
+
+        tool = action.tool
+        act = action.action
+
+        # Validate tool+action
+        if tool not in VALID_TOOL_ACTIONS:
+            return self._make_obs(reward=-1.0, feedback=_api(400, error="unknown_tool", tool=tool))
+        if act not in VALID_TOOL_ACTIONS[tool]:
+            return self._make_obs(reward=-1.0, feedback=_api(400, error="unknown_action", tool=tool, action=act))
+
+        # Check terminal
+        if self._crm["stage"] in ("hired", "lost", "ghosted"):
+            return self._make_obs(reward=0.0, done=True, feedback=_api(400, error="episode_ended"))
+
+        self._state.step_count += 1
+
+        if self._state.step_count >= MAX_STEPS:
+            self._crm["stage"] = "ghosted"
+            return self._make_obs(reward=-3.0, done=True, feedback=_api(200, result="ghosted", reason="timeout"))
+
+        # Passive trust decay — driver loses patience while recruiter isn't talking to them
+        idle_gap = self._state.step_count - self._last_contact_step
+        if idle_gap > 2:
+            # Accelerating decay: longer silence = faster trust loss
+            idle_decay = 0.01 * (idle_gap - 2)
+            self._driver["trust"] = max(0.0, self._driver["trust"] - idle_decay)
+            if self._driver["trust"] <= 0.1:
+                self._crm["stage"] = "ghosted"
+                return self._make_obs(reward=-4.0, done=True, feedback=_api(200, result="ghosted", message=_respond_ghosted(self._driver)))
+
+        # Route to handler
+        if tool == "crm":
+            return self._handle_crm(act, action)
+        elif tool == "messaging":
+            return self._handle_messaging(act, action)
+        elif tool == "approval":
+            return self._handle_approval(act, action)
+        elif tool == "workflow":
+            return self._handle_workflow(act, action)
+
+        return self._make_obs(reward=-1.0, feedback=_api(500, error="internal_error"))
+
+    # --- CRM tool ---
+
+    def _handle_crm(self, act, action):
+        if act == "read_candidate":
+            self._has_read_crm = True
+            self._crm_read_count += 1
+            reward = 0.0 if self._crm_read_count <= 1 else -0.1
+            return self._make_obs(reward=reward, feedback=_api(200, data=self._crm))
+
+        elif act == "update_stage":
+            new_stage = action.stage
+            current = self._crm["stage"]
+
+            if new_stage not in ALL_STAGES:
+                return self._make_obs(reward=-1.0, feedback=_api(400, error="unknown_stage", stage=new_stage))
+
+            # Compute penalty for non-ideal transitions
+            penalty = 0.0
+            if new_stage not in ("lost", "ghosted"):
+                cur_idx = STAGE_ORDER.index(current) if current in STAGE_ORDER else -1
+                new_idx = STAGE_ORDER.index(new_stage) if new_stage in STAGE_ORDER else -1
+                if new_idx >= 0 and cur_idx >= 0:
+                    diff = new_idx - cur_idx
+                    if diff == 0:
+                        # Same stage — wasted action
+                        penalty = -0.1
+                    elif diff == 1:
+                        # Correct next stage — no penalty
+                        penalty = 0.0
+                    elif diff > 1:
+                        # Skipping stages forward — penalize per skip
+                        penalty = -0.5 * (diff - 1)
+                    else:
+                        # Going backwards — heavier penalty
+                        penalty = -1.0 * abs(diff)
+
+            self._crm["stage"] = new_stage
+            if new_stage == "hired":
+                return self._finalize_hire(penalty)
+            if new_stage == "lost":
+                return self._finalize_lost(penalty)
+            return self._make_obs(reward=0.0 + penalty, feedback=_api(200, stage=new_stage))
+
+        elif act == "update_field":
+            field = action.field
+            if field not in VALID_CRM_FIELDS:
+                return self._make_obs(reward=-0.5, feedback=_api(400, error="unknown_field", field=field))
+            self._crm["fields"][field] = action.value
+            return self._make_obs(reward=0.0, feedback=_api(200, field=field, value=action.value))
+
+        elif act == "add_note":
+            if not action.value:
+                return self._make_obs(reward=-0.5, feedback=_api(400, error="empty_note"))
+            self._crm["notes"].append(action.value)
+            return self._make_obs(reward=0.0, feedback=_api(200, notes=len(self._crm["notes"])))
+
+        return self._make_obs(reward=-1.0, feedback=_api(400, error="unknown_action", action=act))
+
+    # --- Messaging tool ---
+
+    def _handle_messaging(self, act, action):
+        if act == "send_message":
+            topic = action.topic
+
+            # Invalid topic — message still reaches driver, they're confused
+            if topic not in VALID_TOPICS:
+                self._last_contact_step = self._state.step_count
+                self._driver["trust"] = max(0.0, self._driver["trust"] - self._driver["decay"] * 2)
+                if self._driver["trust"] <= 0.1:
+                    self._crm["stage"] = "ghosted"
+                    return self._make_obs(reward=-4.0, done=True, feedback=_api(200, result="ghosted", message=_respond_ghosted(self._driver)))
+                self._pending_reply = ("I'm not sure what you're asking about.", topic)
+                return self._make_obs(reward=-1.0, feedback=_api(200, topic=topic, warning="driver_confused"))
+
+            # Penalty for skipping CRM read, but still send
+            penalty = 0.0
+            if not self._has_read_crm:
+                penalty -= 1.0
+            # Penalty for ignoring pending reply (overwrite it), but still send
+            if self._pending_reply is not None:
+                penalty -= 1.0
+                self._pending_reply = None
+
+            self._last_contact_step = self._state.step_count
+
+            # Trust decay on each message
+            self._driver["trust"] = max(0.0, self._driver["trust"] - self._driver["decay"])
+
+            # Trust dropout check
+            if self._driver["trust"] <= 0.1:
+                self._crm["stage"] = "ghosted"
+                return self._make_obs(reward=-4.0, done=True, feedback=_api(200, result="ghosted", message=_respond_ghosted(self._driver)))
+
+            # Generate response based on topic
+            response, reward = self._generate_message_response(topic, action.job_id)
+            if response is None:
+                return self._make_obs(reward=reward + penalty, feedback=_api(404, error="no_valid_target", topic=topic))
+            if response == "NEGOTIATION_EXHAUSTED":
+                self._crm["stage"] = "lost"
+                return self._make_obs(reward=reward + penalty, done=True, feedback=_api(200, result="lost", reason="negotiation_exhausted"))
+            self._pending_reply = (response, topic)
+            return self._make_obs(reward=reward + penalty, feedback=_api(200, topic=topic))
+
+        elif act == "read_reply":
+            if self._pending_reply is None:
+                return self._make_obs(reward=-0.5, feedback=_api(200, reply=None))
+            self._last_contact_step = self._state.step_count
+
+            response, topic = self._pending_reply
+            self._pending_reply = None
+
+            # Auto-add to discovered info for screening topics
+            if topic in SCREENING_TOPICS:
+                self._discovered_info.append(f"[{topic.upper().replace('_', ' ')}] {response}")
+                self._asked.add(f"ask_{topic}")
+            elif topic == "pitch":
+                self._discovered_info.append(f"[PITCH] {response}")
+            elif topic in ("negotiate_pay", "negotiate_home_time", "signing_bonus", "address_concern"):
+                self._discovered_info.append(f"[NEGOTIATE: {topic.replace('_', ' ')}] {response}")
+            elif topic == "offer":
+                self._discovered_info.append(f"[OFFER] {response}")
+
+            return self._make_obs(reward=0.0, feedback=_api(200, topic=topic, reply=response))
+
+        return self._make_obs(reward=-1.0, feedback=_api(400, error="unknown_action", action=act))
+
+    def _generate_message_response(self, topic, job_id):
+        """Generate driver's response to a message. Returns (response, reward)."""
+        reward = -0.1  # base step cost
+
+        # --- Contact topics ---
+        if topic in ("greeting", "call"):
+            if self._contacted:
+                return _respond_contact_repeat(self._driver), -1.0
+            self._contacted = True
+            pref = self._driver["preferred_contact"]
+            matches = (topic == "greeting" and pref == "text") or (topic == "call" and pref == "call")
+            if matches:
+                self._driver["trust"] = min(1.0, self._driver["trust"] + 0.15)
+                return _respond_contact_good(self._driver, topic), 1.0
+            else:
+                self._driver["trust"] = max(0.0, self._driver["trust"] - 0.10)
+                return _respond_contact_wrong(self._driver, topic), -0.3
+
+        # --- Screening topics ---
+        if topic in SCREENING_TOPICS:
+            if not self._contacted:
+                # Still works but driver is cold — penalty
+                self._driver["trust"] = max(0.0, self._driver["trust"] - 0.15)
+            ask_key = f"ask_{topic}"
+            if ask_key in self._asked:
+                return _respond_repeat_question(self._driver, topic.replace("_", " ")), -0.5
+
+            respond_map = {
+                "experience": _respond_experience,
+                "home_time": _respond_home_time,
+                "pay": _respond_pay,
+                "equipment": _respond_equipment,
+                "route": _respond_route,
+                "deal_breakers": _respond_deal_breakers,
+                "availability": _respond_availability,
+                "violations": _respond_violations,
+                "medical_card": _respond_medical_card,
+                "references": _respond_references,
+            }
+            response = respond_map[topic](self._driver)
+            penalty = -1.0 if not self._contacted else -0.1
+            return response, penalty
+
+        # --- Pitch ---
+        if topic == "pitch":
+            if not self._contacted:
+                self._driver["trust"] = max(0.0, self._driver["trust"] - 0.15)
+            matching = [j for j in self._jobs if j["job_id"] == job_id]
+            if not matching:
+                # No match — pick nothing, return None (will be caught by handler)
+                return None, -1.0
+            penalty = -1.0 if not self._contacted else -0.1
+            return _respond_pitch(self._driver, matching[0]), penalty
+
+        # --- Offer ---
+        if topic == "offer":
+            penalty = 0.0
+            if self._approval_status != "approved":
+                # Allowed but heavy penalty — driver gets confused
+                self._driver["trust"] = max(0.0, self._driver["trust"] - 0.2)
+                penalty = -2.0
+            job_id_to_use = self._approval_job_id if job_id < 0 else job_id
+            matching = [j for j in self._jobs if j["job_id"] == job_id_to_use]
+            if not matching:
+                return None, -1.0 + penalty
+            job = matching[0]
+            self._matched_job_id = job_id_to_use
+            score, issues, fatal = score_job_fit(self._driver, job)
+            if not fatal:
+                score = min(100, score + self._negotiation_score_bonus)
+            if fatal:
+                return _respond_offer_reject(self._driver, issues[0]), -0.5 + penalty
+            elif score >= 70:
+                return _respond_offer_accept(self._driver, job), 0.0 + penalty
+            elif score >= 50:
+                concern = issues[0] if issues else "minor concerns"
+                self._negotiation_concerns = issues
+                return _respond_offer_concerns(self._driver, job, concern), 0.0 + penalty
+            else:
+                return _respond_offer_reject(self._driver, issues[0] if issues else "not a fit"), -0.5 + penalty
+
+        # --- Negotiation topics ---
+        if topic in ("negotiate_pay", "negotiate_home_time", "signing_bonus", "address_concern"):
+            if self._matched_job_id < 0 and self._approval_job_id >= 0:
+                self._matched_job_id = self._approval_job_id
+            if self._matched_job_id < 0:
+                return None, -1.0
+            if self._negotiation_round >= 5:
+                return "NEGOTIATION_EXHAUSTED", -2.0
+
+            self._negotiation_round += 1
+            matches = [j for j in self._jobs if j["job_id"] == self._matched_job_id]
+            if not matches:
+                return None, -1.0
+            job = matches[0]
+            if not self._negotiation_concerns:
+                self._negotiation_concerns = _get_negotiation_concerns(self._driver, job)
+            response = _respond_negotiation(self._driver, topic, job, self._negotiation_concerns)
+
+            # Score bonus
+            if topic == "address_concern" and self._negotiation_concerns:
+                self._negotiation_score_bonus += 15
+                self._negotiation_concerns.pop(0)
+            elif topic == "negotiate_pay" and any("pay" in c.lower() for c in self._negotiation_concerns):
+                self._negotiation_score_bonus += 10
+                self._negotiation_concerns = [c for c in self._negotiation_concerns if "pay" not in c.lower()]
+            elif topic == "negotiate_home_time" and any("home time" in c.lower() for c in self._negotiation_concerns):
+                self._negotiation_score_bonus += 10
+                self._negotiation_concerns = [c for c in self._negotiation_concerns if "home time" not in c.lower()]
+            elif topic == "signing_bonus":
+                self._negotiation_score_bonus += 5
+            else:
+                self._negotiation_score_bonus += 2
+
+            # Extra trust decay during negotiation
+            self._driver["trust"] = max(0.0, self._driver["trust"] - 0.01)
+            return response, -0.1
+
+        return None, -1.0
+
+    # --- Approval tool ---
+
+    def _handle_approval(self, act, action):
+        if act == "request_approval":
+            if action.job_id < 0:
+                return self._make_obs(reward=-1.0, feedback=_api(400, error="job_id_required"))
+            matching = [j for j in self._jobs if j["job_id"] == action.job_id]
+            if not matching:
+                return self._make_obs(reward=-1.0, feedback=_api(404, error="job_not_found", job_id=action.job_id))
+            # Allow re-request but penalize — resets approval
+            penalty = -0.5 if self._approval_status in ("pending", "approved") else 0.0
+            self._approval_status = "pending"
+            self._approval_job_id = action.job_id
+            return self._make_obs(reward=0.0 + penalty, feedback=_api(202, approval_status="pending", job_id=action.job_id))
+
+        elif act == "check_approval":
+            if self._approval_status == "none":
+                return self._make_obs(reward=-0.5, feedback=_api(200, approval_status="none"))
+            if self._approval_status == "pending":
+                return self._make_obs(reward=-0.1, feedback=_api(202, approval_status="pending"))
+            return self._make_obs(
+                reward=0.5 if self._approval_status == "approved" else -0.5,
+                feedback=_api(200, approval_status=self._approval_status, job_id=self._approval_job_id)
+            )
+
+        return self._make_obs(reward=-1.0, feedback=_api(400, error="unknown_action", action=act))
+
+    # --- Workflow tool ---
+
+    def _handle_workflow(self, act, action):
+        if act == "wait":
+            if self._approval_status == "pending":
+                # Process approval based on job quality
+                job = [j for j in self._jobs if j["job_id"] == self._approval_job_id]
+                if job:
+                    score, _, fatal = score_job_fit(self._driver, job[0])
+                    if fatal:
+                        self._approval_status = "denied"
+                    else:
+                        self._approval_status = "approved"
+                else:
+                    self._approval_status = "denied"
+                return self._make_obs(reward=0.0, feedback=_api(200, elapsed="1h"))
+
+            # Generic wait — trust decay + penalty for wasting time
+            self._driver["trust"] = max(0.0, self._driver["trust"] - 0.02)
+            return self._make_obs(reward=-0.5, feedback=_api(200, elapsed="1h"))
+
+        return self._make_obs(reward=-1.0, feedback=_api(400, error="unknown_action", action=act))
+
+    # --- Terminal handlers ---
+
+    def _score_crm(self):
+        """Score CRM accuracy — compare recorded fields to ground truth."""
+        ground_truth = {
+            "cdl_class": self._driver["cdl_class"],
+            "years_experience": str(self._driver["experience_years"]),
+            "location": self._driver["location"],
+            "home_time_pref": self._driver["home_time_pref"],
+            "pay_expectation": str(self._driver["min_cpm"]),
+            "equipment_pref": self._driver["equipment_pref"],
+            "route_pref": self._driver["route_pref"],
+            "availability": self._driver["availability"],
+            "violations": self._driver["violations"],
+            "medical_card": self._driver["medical_card"],
+            "references": self._driver["references"],
+        }
+        # Endorsements and deal_breakers are lists — normalize
+        ground_truth["endorsements"] = ", ".join(sorted(self._driver["endorsements"])) if self._driver["endorsements"] else "none"
+        ground_truth["deal_breakers"] = ", ".join(sorted(self._driver["deal_breakers"]))
+
+        score = 0.0
+        for field, truth in ground_truth.items():
+            recorded = self._crm["fields"].get(field, "")
+            if not recorded:
+                continue
+            # Exact match (case-insensitive)
+            if recorded.strip().lower() == truth.lower():
+                score += 0.4
+            # Partial match — truth appears in recorded or vice versa
+            elif truth.lower() in recorded.strip().lower() or recorded.strip().lower() in truth.lower():
+                score += 0.2
+            else:
+                # Wrong value recorded — small penalty
+                score -= 0.1
+
+        # Small bonus for notes (shows diligence)
+        score += min(0.5, len(self._crm["notes"]) * 0.1)
+
+        # Cap: up to 5.0 bonus for perfect CRM (13 fields × 0.4 = 5.2)
+        return max(0.0, min(5.0, score))
+
+    def _finalize_hire(self, stage_penalty=0.0):
+        """Handle stage transition to hired — compute final reward."""
+        crm_bonus = self._score_crm()
+
+        if self._approval_status != "approved":
+            self._crm["stage"] = "lost"
+            return self._make_obs(
+                reward=-5.0 + stage_penalty, done=True,
+                feedback=_api(200, result="lost", reason="no_approval")
+            )
+
+        job_id = self._approval_job_id
+        matching = [j for j in self._jobs if j["job_id"] == job_id]
+        if not matching:
+            self._crm["stage"] = "lost"
+            return self._make_obs(
+                reward=-5.0 + stage_penalty, done=True,
+                feedback=_api(200, result="lost", reason="no_job")
+            )
+
+        job = matching[0]
+        score, issues, fatal = score_job_fit(self._driver, job)
+        if not fatal:
+            score = min(100, score + self._negotiation_score_bonus)
+
+        if fatal:
+            self._crm["stage"] = "lost"
+            return self._make_obs(
+                reward=-5.0 + stage_penalty, done=True,
+                feedback=_api(200, result="rejected", reason=issues[0], job_id=job_id)
+            )
+        elif score >= 70:
+            return self._make_obs(
+                reward=10.0 + crm_bonus + stage_penalty, done=True,
+                feedback=_api(200, result="hired", job_id=job_id, score=score, crm_bonus=round(crm_bonus, 1))
+            )
+        elif score >= 50:
+            return self._make_obs(
+                reward=4.0 + crm_bonus + stage_penalty, done=True,
+                feedback=_api(200, result="hired_with_reservations", job_id=job_id, score=score, concern=issues[0] if issues else "minor")
+            )
+        else:
+            self._crm["stage"] = "lost"
+            return self._make_obs(
+                reward=-5.0 + stage_penalty, done=True,
+                feedback=_api(200, result="rejected", reason=issues[0] if issues else "poor_fit", job_id=job_id)
+            )
+
+    def _finalize_lost(self, stage_penalty=0.0):
+        """Handle stage transition to lost."""
+        has_good = any(score_job_fit(self._driver, j)[0] >= 70 for j in self._jobs)
+        if has_good:
+            return self._make_obs(
+                reward=-3.0 + stage_penalty, done=True,
+                feedback=_api(200, result="lost", good_match_existed=True)
+            )
+        else:
+            return self._make_obs(
+                reward=1.0 + stage_penalty, done=True,
+                feedback=_api(200, result="lost", good_match_existed=False)
+            )
+
+    @property
+    def state(self) -> State:
+        return self._state

server/requirements.txt

@@ -0,0 +1,6 @@
+openenv[core]>=0.2.0
+fastapi>=0.115.0
+uvicorn>=0.24.0
+
+
+

train_colab.ipynb

@@ -0,0 +1,558 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 🚛 Driver Recruit Environment — RL Training with TRL\n",
+    "\n",
+    "Train a 3B LLM to recruit truck drivers using REINFORCE with TRL.\n",
+    "\n",
+    "The model learns to choose the right screening topics to ask drivers,\n",
+    "then the auto-pilot handles CRM updates, approval, and hiring.\n",
+    "\n",
+    "**Environment**: [OpenEnv 0.2.1](https://github.com/meta-pytorch/OpenEnv) deployed on HF Spaces\n",
+    "\n",
+    "**Model**: Qwen/Qwen2.5-3B-Instruct\n",
+    "\n",
+    "**Algorithm**: REINFORCE with batch-level advantage normalization"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Install Dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install -q openenv-core[core]==0.2.1 trl transformers torch accelerate"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Connect to the Environment\n",
+    "\n",
+    "The recruiting environment is deployed on HF Spaces. Replace the URL below with your Space URL."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import random\n",
+    "import re\n",
+    "\n",
+    "import torch\n",
+    "import torch.nn.functional as F\n",
+    "from transformers import AutoTokenizer, AutoModelForCausalLM\n",
+    "\n",
+    "# --- Connect to environment ---\n",
+    "# Replace with your HF Space URL\n",
+    "ENV_URL = \"https://YOUR-USERNAME-recruitopenenv.hf.space\"  # <-- CHANGE THIS\n",
+    "\n",
+    "from openenv.client import EnvClient\n",
+    "\n",
+    "# Quick test: reset and check the env is alive\n",
+    "import requests\n",
+    "resp = requests.post(f\"{ENV_URL}/reset\", json={\"seed\": 42})\n",
+    "data = resp.json()\n",
+    "print(f\"Driver: {data['observation']['driver_name']}\")\n",
+    "print(f\"Stage: {data['observation']['stage']}\")\n",
+    "print(\"Environment connected!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Environment Helper Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def env_reset(seed=None):\n",
+    "    \"\"\"Reset environment via HTTP.\"\"\"\n",
+    "    payload = {\"seed\": seed} if seed else {}\n",
+    "    resp = requests.post(f\"{ENV_URL}/reset\", json=payload)\n",
+    "    return resp.json()\n",
+    "\n",
+    "def env_step(tool, action, **kwargs):\n",
+    "    \"\"\"Step environment via HTTP.\"\"\"\n",
+    "    payload = {\"tool\": tool, \"action\": action, **kwargs}\n",
+    "    resp = requests.post(f\"{ENV_URL}/step\", json=payload)\n",
+    "    return resp.json()\n",
+    "\n",
+    "# --- Topic-based auto-pilot ---\n",
+    "SCREENING_TOPICS = [\n",
+    "    \"experience\", \"home_time\", \"pay\", \"equipment\", \"route\",\n",
+    "    \"deal_breakers\", \"availability\", \"violations\", \"medical_card\", \"references\",\n",
+    "]\n",
+    "\n",
+    "SYSTEM_PROMPT = \"\"\"You are a truck driver recruiter screening a candidate. Choose the next topic to discuss.\n",
+    "\n",
+    "Topics for first contact: greeting (text), call (phone)\n",
+    "Screening topics: experience, home_time, pay, equipment, route, deal_breakers, availability, violations, medical_card, references\n",
+    "Say \"done\" when you have enough info to proceed with hiring.\n",
+    "\n",
+    "Respond with ONLY the topic name, nothing else.\"\"\"\n",
+    "\n",
+    "ALL_TOPICS = [\"greeting\", \"call\"] + SCREENING_TOPICS + [\"done\"]\n",
+    "\n",
+    "def parse_topic(text):\n",
+    "    \"\"\"Extract topic name from model output.\"\"\"\n",
+    "    text = text.strip().lower().replace('\"', '').replace(\"'\", \"\")\n",
+    "    text = text.split(\"\\n\")[0].strip().split(\".\")[0].strip()\n",
+    "    for topic in ALL_TOPICS:\n",
+    "        if topic in text or topic.replace(\"_\", \" \") in text:\n",
+    "            return topic\n",
+    "    if \"deal\" in text: return \"deal_breakers\"\n",
+    "    if \"home\" in text: return \"home_time\"\n",
+    "    if \"medical\" in text: return \"medical_card\"\n",
+    "    return \"done\"\n",
+    "\n",
+    "def build_prompt(obs, asked):\n",
+    "    \"\"\"Build prompt showing state and available topics.\"\"\"\n",
+    "    parts = [f\"Driver: {obs['driver_name']}\"]\n",
+    "    if obs.get('jobs_summary'):\n",
+    "        parts.append(f\"Jobs:\\n{obs['jobs_summary']}\")\n",
+    "    if obs.get('discovered_info'):\n",
+    "        parts.append(f\"Discovered:\\n{obs['discovered_info']}\")\n",
+    "    parts.append(f\"Stage: {obs['stage']}\")\n",
+    "    if asked:\n",
+    "        parts.append(f\"Already asked: {', '.join(asked)}\")\n",
+    "    available = [t for t in ALL_TOPICS if t not in asked]\n",
+    "    parts.append(f\"Available: {', '.join(available)}\")\n",
+    "    return \"\\n\".join(parts)\n",
+    "\n",
+    "print(\"Helpers loaded!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Run a Demo Episode\n",
+    "\n",
+    "Watch the auto-pilot run a full recruiting episode."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_demo_episode(seed=42):\n",
+    "    \"\"\"Run one full episode with scripted topic choices.\"\"\"\n",
+    "    state = env_reset(seed=seed)\n",
+    "    obs = state[\"observation\"]\n",
+    "    total_reward = 0.0\n",
+    "    print(f\"=== Driver: {obs['driver_name']} ===\")\n",
+    "\n",
+    "    # Read CRM\n",
+    "    state = env_step(\"crm\", \"read_candidate\")\n",
+    "    total_reward += state[\"reward\"]\n",
+    "    obs = state[\"observation\"]\n",
+    "    print(f\"\\nJobs available:\\n{obs['jobs_summary'][:200]}...\")\n",
+    "\n",
+    "    # Greet\n",
+    "    state = env_step(\"messaging\", \"send_message\", topic=\"greeting\")\n",
+    "    total_reward += state[\"reward\"]\n",
+    "    print(f\"\\nGreeting reward: {state['reward']}\")\n",
+    "\n",
+    "    state = env_step(\"messaging\", \"read_reply\")\n",
+    "    total_reward += state[\"reward\"]\n",
+    "    obs = state[\"observation\"]\n",
+    "\n",
+    "    state = env_step(\"crm\", \"update_stage\", stage=\"contacted\")\n",
+    "    total_reward += state[\"reward\"]\n",
+    "\n",
+    "    # Screen\n",
+    "    for topic in [\"experience\", \"deal_breakers\", \"pay\", \"home_time\"]:\n",
+    "        if state.get(\"done\"): break\n",
+    "        state = env_step(\"messaging\", \"send_message\", topic=topic)\n",
+    "        total_reward += state[\"reward\"]\n",
+    "        state = env_step(\"messaging\", \"read_reply\")\n",
+    "        total_reward += state[\"reward\"]\n",
+    "        obs = state[\"observation\"]\n",
+    "        print(f\"  {topic}: reward={state['reward']:.1f}\")\n",
+    "\n",
+    "    print(f\"\\nDiscovered:\\n{obs.get('discovered_info', 'none')[:300]}\")\n",
+    "\n",
+    "    # Approval + hire\n",
+    "    state = env_step(\"crm\", \"update_stage\", stage=\"interested\")\n",
+    "    total_reward += state[\"reward\"]\n",
+    "    state = env_step(\"approval\", \"request_approval\", job_id=0)\n",
+    "    total_reward += state[\"reward\"]\n",
+    "    state = env_step(\"workflow\", \"wait\")\n",
+    "    total_reward += state[\"reward\"]\n",
+    "    state = env_step(\"approval\", \"check_approval\")\n",
+    "    total_reward += state[\"reward\"]\n",
+    "    state = env_step(\"crm\", \"update_stage\", stage=\"approval_pending\")\n",
+    "    total_reward += state[\"reward\"]\n",
+    "    state = env_step(\"messaging\", \"send_message\", topic=\"offer\", job_id=0)\n",
+    "    total_reward += state[\"reward\"]\n",
+    "    state = env_step(\"messaging\", \"read_reply\")\n",
+    "    total_reward += state[\"reward\"]\n",
+    "    state = env_step(\"crm\", \"update_stage\", stage=\"offer_sent\")\n",
+    "    total_reward += state[\"reward\"]\n",
+    "    state = env_step(\"crm\", \"update_stage\", stage=\"hired\")\n",
+    "    total_reward += state[\"reward\"]\n",
+    "\n",
+    "    obs = state[\"observation\"]\n",
+    "    print(f\"\\nFinal stage: {obs['stage']}\")\n",
+    "    print(f\"Total reward: {total_reward:.1f}\")\n",
+    "    print(f\"Done: {state.get('done')}\")\n",
+    "    return total_reward\n",
+    "\n",
+    "run_demo_episode()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. Load Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "MODEL_NAME = \"Qwen/Qwen2.5-3B-Instruct\"\n",
+    "TEMPERATURE = 1.5\n",
+    "MAX_NEW_TOKENS = 32\n",
+    "MAX_TOPICS = 8\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)\n",
+    "if tokenizer.pad_token_id is None:\n",
+    "    tokenizer.pad_token_id = tokenizer.eos_token_id\n",
+    "\n",
+    "model = AutoModelForCausalLM.from_pretrained(\n",
+    "    MODEL_NAME,\n",
+    "    torch_dtype=torch.bfloat16,\n",
+    "    device_map=\"auto\",\n",
+    ")\n",
+    "model.gradient_checkpointing_enable()\n",
+    "\n",
+    "optimizer = torch.optim.AdamW(model.parameters(), lr=5e-6)\n",
+    "device = next(model.parameters()).device\n",
+    "print(f\"Model loaded on {device}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6. Training Loop — REINFORCE with Auto-Pilot\n",
+    "\n",
+    "The model only picks screening topics (1-5 tokens per decision).\n",
+    "The auto-pilot handles CRM, stages, approval, and hiring.\n",
+    "Rewards come from the full episode outcome."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def rollout_episode(model, tokenizer, device, seed=None):\n",
+    "    \"\"\"Run one auto-piloted episode. Model picks topics, wrapper does the rest.\"\"\"\n",
+    "    if seed is None:\n",
+    "        seed = random.randint(0, 2**31 - 1)\n",
+    "\n",
+    "    state = env_reset(seed=seed)\n",
+    "    obs = state[\"observation\"]\n",
+    "    total_reward = 0.0\n",
+    "\n",
+    "    # Auto: read CRM\n",
+    "    state = env_step(\"crm\", \"read_candidate\")\n",
+    "    total_reward += state[\"reward\"]\n",
+    "    obs = state[\"observation\"]\n",
+    "\n",
+    "    if state.get(\"done\"):\n",
+    "        return None\n",
+    "\n",
+    "    turn_data = []\n",
+    "    asked = []\n",
+    "    contacted = False\n",
+    "\n",
+    "    for _ in range(MAX_TOPICS):\n",
+    "        if state.get(\"done\"):\n",
+    "            break\n",
+    "\n",
+    "        # Build prompt\n",
+    "        obs_text = build_prompt(obs, asked)\n",
+    "        messages = [\n",
+    "            {\"role\": \"system\", \"content\": SYSTEM_PROMPT},\n",
+    "            {\"role\": \"user\", \"content\": obs_text},\n",
+    "        ]\n",
+    "        prompt = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)\n",
+    "        input_ids = tokenizer.encode(prompt, return_tensors=\"pt\").to(device)\n",
+    "\n",
+    "        # Model generates topic\n",
+    "        with torch.no_grad():\n",
+    "            output = model.generate(\n",
+    "                input_ids, max_new_tokens=MAX_NEW_TOKENS,\n",
+    "                do_sample=True, temperature=TEMPERATURE,\n",
+    "                pad_token_id=tokenizer.pad_token_id,\n",
+    "            )\n",
+    "        gen_ids = output[0, input_ids.shape[1]:].tolist()\n",
+    "        response = tokenizer.decode(gen_ids, skip_special_tokens=True)\n",
+    "        topic = parse_topic(response)\n",
+    "\n",
+    "        turn_data.append({\n",
+    "            \"prompt_ids\": input_ids[0].tolist(),\n",
+    "            \"gen_ids\": gen_ids,\n",
+    "            \"topic\": topic,\n",
+    "            \"turn_reward\": 0.0,\n",
+    "        })\n",
+    "\n",
+    "        if topic == \"done\":\n",
+    "            break\n",
+    "        if topic in asked:\n",
+    "            total_reward -= 0.5\n",
+    "            turn_data[-1][\"turn_reward\"] = -0.5\n",
+    "            asked.append(topic)\n",
+    "            continue\n",
+    "\n",
+    "        asked.append(topic)\n",
+    "\n",
+    "        # Auto: send_message + read_reply\n",
+    "        state = env_step(\"messaging\", \"send_message\", topic=topic)\n",
+    "        turn_reward = state[\"reward\"]\n",
+    "        total_reward += state[\"reward\"]\n",
+    "        obs = state[\"observation\"]\n",
+    "\n",
+    "        if not state.get(\"done\"):\n",
+    "            state = env_step(\"messaging\", \"read_reply\")\n",
+    "            turn_reward += state[\"reward\"]\n",
+    "            total_reward += state[\"reward\"]\n",
+    "            obs = state[\"observation\"]\n",
+    "\n",
+    "        # Auto: update stage after contact\n",
+    "        if topic in (\"greeting\", \"call\") and not contacted and not state.get(\"done\"):\n",
+    "            contacted = True\n",
+    "            state = env_step(\"crm\", \"update_stage\", stage=\"contacted\")\n",
+    "            turn_reward += state[\"reward\"]\n",
+    "            total_reward += state[\"reward\"]\n",
+    "            obs = state[\"observation\"]\n",
+    "\n",
+    "        turn_data[-1][\"turn_reward\"] = turn_reward\n",
+    "\n",
+    "    if not turn_data:\n",
+    "        return None\n",
+    "\n",
+    "    # Auto: approval + offer + hire\n",
+    "    if not state.get(\"done\") and contacted:\n",
+    "        for action_spec in [\n",
+    "            (\"crm\", \"update_stage\", {\"stage\": \"interested\"}),\n",
+    "            (\"approval\", \"request_approval\", {\"job_id\": 0}),\n",
+    "            (\"workflow\", \"wait\", {}),\n",
+    "            (\"approval\", \"check_approval\", {}),\n",
+    "            (\"crm\", \"update_stage\", {\"stage\": \"approval_pending\"}),\n",
+    "            (\"messaging\", \"send_message\", {\"topic\": \"offer\", \"job_id\": 0}),\n",
+    "            (\"messaging\", \"read_reply\", {}),\n",
+    "            (\"crm\", \"update_stage\", {\"stage\": \"offer_sent\"}),\n",
+    "            (\"crm\", \"update_stage\", {\"stage\": \"hired\"}),\n",
+    "        ]:\n",
+    "            if state.get(\"done\"): break\n",
+    "            state = env_step(action_spec[0], action_spec[1], **action_spec[2])\n",
+    "            total_reward += state[\"reward\"]\n",
+    "\n",
+    "    # Sample one turn for training\n",
+    "    t = random.randrange(len(turn_data))\n",
+    "    td = turn_data[t]\n",
+    "\n",
+    "    return {\n",
+    "        \"prompt_ids\": td[\"prompt_ids\"],\n",
+    "        \"gen_ids\": td[\"gen_ids\"][:MAX_NEW_TOKENS],\n",
+    "        \"reward\": total_reward,\n",
+    "        \"stage\": obs.get(\"stage\", \"unknown\"),\n",
+    "        \"topic\": td[\"topic\"],\n",
+    "        \"num_topics\": len(asked),\n",
+    "    }\n",
+    "\n",
+    "# Quick test\n",
+    "ep = rollout_episode(model, tokenizer, device)\n",
+    "if ep:\n",
+    "    print(f\"Topic chosen: {ep['topic']}, Reward: {ep['reward']:.1f}, Stage: {ep['stage']}, Topics asked: {ep['num_topics']}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# --- REINFORCE Training Loop ---\n",
+    "BATCH_SIZE = 4\n",
+    "NUM_STEPS = 50\n",
+    "\n",
+    "print(f\"Training for {NUM_STEPS} steps, batch size {BATCH_SIZE}\")\n",
+    "print(\"=\" * 60)\n",
+    "\n",
+    "history = {\"loss\": [], \"reward_mean\": [], \"reward_std\": [], \"grad_norm\": []}\n",
+    "\n",
+    "for step in range(1, NUM_STEPS + 1):\n",
+    "    # --- Rollout (no gradients) ---\n",
+    "    model.eval()\n",
+    "    episodes = []\n",
+    "    for i in range(BATCH_SIZE):\n",
+    "        ep = rollout_episode(model, tokenizer, device)\n",
+    "        if ep and ep[\"gen_ids\"]:\n",
+    "            episodes.append(ep)\n",
+    "\n",
+    "    if len(episodes) < 2:\n",
+    "        print(f\"Step {step}: not enough episodes, skipping\")\n",
+    "        continue\n",
+    "\n",
+    "    # --- Batch-level advantages ---\n",
+    "    rewards = [ep[\"reward\"] for ep in episodes]\n",
+    "    mean_r = sum(rewards) / len(rewards)\n",
+    "    std_r = max(torch.tensor(rewards).std().item(), 1e-4)\n",
+    "    advantages = [(r - mean_r) / std_r for r in rewards]\n",
+    "\n",
+    "    # --- REINFORCE update ---\n",
+    "    model.train()\n",
+    "    optimizer.zero_grad()\n",
+    "    total_loss = 0.0\n",
+    "\n",
+    "    for ep, adv in zip(episodes, advantages):\n",
+    "        input_ids = torch.tensor(\n",
+    "            [ep[\"prompt_ids\"] + ep[\"gen_ids\"]], device=device\n",
+    "        )\n",
+    "        prompt_len = len(ep[\"prompt_ids\"])\n",
+    "        comp_len = len(ep[\"gen_ids\"])\n",
+    "        if comp_len == 0:\n",
+    "            continue\n",
+    "\n",
+    "        outputs = model(input_ids)\n",
+    "        logits = outputs.logits[0, prompt_len - 1 : prompt_len + comp_len - 1]\n",
+    "        targets = input_ids[0, prompt_len : prompt_len + comp_len]\n",
+    "        log_probs = F.log_softmax(logits, dim=-1)\n",
+    "        token_lps = log_probs.gather(1, targets.unsqueeze(1)).squeeze(1)\n",
+    "\n",
+    "        loss = -(adv * token_lps.sum()) / len(episodes)\n",
+    "        loss.backward()\n",
+    "        total_loss += loss.item()\n",
+    "\n",
+    "    grad_norm = torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0).item()\n",
+    "    optimizer.step()\n",
+    "\n",
+    "    # --- Log ---\n",
+    "    history[\"loss\"].append(total_loss)\n",
+    "    history[\"reward_mean\"].append(mean_r)\n",
+    "    history[\"reward_std\"].append(std_r)\n",
+    "    history[\"grad_norm\"].append(grad_norm)\n",
+    "\n",
+    "    topics = [ep[\"topic\"] for ep in episodes]\n",
+    "    print(f\"Step {step:3d} | loss={total_loss:+.3f} | reward={mean_r:+.1f}±{std_r:.1f} | \"\n",
+    "          f\"grad={grad_norm:.3f} | topics={topics}\")\n",
+    "\n",
+    "print(\"\\nTraining complete!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 7. Plot Training Curves"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "fig, axes = plt.subplots(2, 2, figsize=(12, 8))\n",
+    "fig.suptitle(\"Driver Recruit RL Training\", fontsize=14)\n",
+    "\n",
+    "axes[0, 0].plot(history[\"loss\"])\n",
+    "axes[0, 0].set_title(\"Loss\")\n",
+    "axes[0, 0].set_xlabel(\"Step\")\n",
+    "\n",
+    "axes[0, 1].plot(history[\"reward_mean\"])\n",
+    "axes[0, 1].set_title(\"Mean Reward\")\n",
+    "axes[0, 1].set_xlabel(\"Step\")\n",
+    "\n",
+    "axes[1, 0].plot(history[\"reward_std\"])\n",
+    "axes[1, 0].set_title(\"Reward Std\")\n",
+    "axes[1, 0].set_xlabel(\"Step\")\n",
+    "\n",
+    "axes[1, 1].plot(history[\"grad_norm\"])\n",
+    "axes[1, 1].set_title(\"Gradient Norm\")\n",
+    "axes[1, 1].set_xlabel(\"Step\")\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 8. Test the Trained Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"=== Testing trained model ===\")\n",
+    "model.eval()\n",
+    "test_rewards = []\n",
+    "for i in range(5):\n",
+    "    ep = rollout_episode(model, tokenizer, device)\n",
+    "    if ep:\n",
+    "        test_rewards.append(ep[\"reward\"])\n",
+    "        print(f\"  Episode {i+1}: reward={ep['reward']:.1f}, stage={ep['stage']}, \"\n",
+    "              f\"topics={ep['num_topics']}, chose={ep['topic']}\")\n",
+    "\n",
+    "if test_rewards:\n",
+    "    print(f\"\\nMean test reward: {sum(test_rewards)/len(test_rewards):.1f}\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.10.0"
+  },
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "T4",
+   "provenance": []
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

train_grpo.py

@@ -0,0 +1,431 @@
+"""
+GRPO training script for the Driver Recruit Environment.
+
+Uses TRL's GRPOTrainer with rollout_func for multi-turn episodes.
+The model controls EVERY action in the episode via tool calls.
+
+Usage:
+    python train_grpo.py --model Qwen/Qwen2.5-3B-Instruct --use-qlora
+"""
+
+import argparse
+import json
+import random
+
+from datasets import Dataset
+from transformers import AutoTokenizer, BitsAndBytesConfig
+import torch
+
+from recruitopenenv import RecruitopenenvEnv, RecruitopenenvAction
+from trl import GRPOConfig, GRPOTrainer
+from trl.experimental.openenv import generate_rollout_completions
+
+# --- Prompt templates ---
+
+SYSTEM_PROMPT = """You are a truck driver recruiter using a CRM system. You only know the driver's name. You must discover their qualifications through conversation, record info in the CRM, get approval, and hire them.
+
+You have 4 tools:
+
+## crm
+- read_candidate: Read the current CRM record
+- update_stage: Advance pipeline (contacted → interested → approval_pending → offer_sent → hired)
+- update_field: Record info (field + value)
+- add_note: Add a free-text note
+
+## messaging
+- send_message: Send a message (topic: greeting, call, experience, home_time, pay, equipment, route, deal_breakers, availability, violations, medical_card, references, pitch, offer, negotiate_pay, negotiate_home_time, signing_bonus, address_concern)
+- read_reply: Read the driver's response
+
+## approval
+- request_approval: Request approval for a job (needs job_id)
+- check_approval: Check approval status
+
+## workflow
+- wait: Advance time (needed for approval processing)
+
+## Rules
+- Must read CRM before messaging
+- Must read_reply before sending another message
+- Must request_approval and wait before sending offer
+- Must follow stage order: lead → contacted → interested → approval_pending → offer_sent → hired
+- Record important info in CRM with update_field
+- Too many messages hurt trust
+
+## Workflow
+1. crm.read_candidate
+2. messaging.send_message (greeting/call) → read_reply → update_stage(contacted)
+3. messaging.send_message (screening topics) → read_reply → crm.update_field
+4. crm.update_stage(interested)
+5. approval.request_approval → workflow.wait → approval.check_approval
+6. crm.update_stage(approval_pending)
+7. messaging.send_message(offer) → read_reply
+8. crm.update_stage(offer_sent) → crm.update_stage(hired)
+
+Respond with ONLY JSON:
+{"tool": "crm", "action": "read_candidate"}
+{"tool": "messaging", "action": "send_message", "topic": "experience"}
+{"tool": "messaging", "action": "read_reply"}
+{"tool": "crm", "action": "update_field", "field": "cdl_class", "value": "A"}
+{"tool": "crm", "action": "update_stage", "stage": "contacted"}
+{"tool": "approval", "action": "request_approval", "job_id": 2}
+{"tool": "workflow", "action": "wait"}
+{"tool": "approval", "action": "check_approval"}
+{"tool": "messaging", "action": "send_message", "topic": "offer", "job_id": 2}
+{"tool": "crm", "action": "update_stage", "stage": "hired"}"""
+
+
+def format_observation(obs):
+    """Format observation into a user prompt for the LLM."""
+    parts = [f"Driver: {obs.driver_name}"]
+    if obs.crm_summary:
+        parts.append(f"CRM:\n{obs.crm_summary}")
+    if obs.jobs_summary:
+        parts.append(f"Jobs:\n{obs.jobs_summary}")
+    if obs.discovered_info:
+        parts.append(f"Discovered:\n{obs.discovered_info}")
+    status = f"Stage: {obs.stage}"
+    if obs.pending_reply:
+        status += " | PENDING REPLY"
+    parts.append(status)
+    if obs.feedback:
+        parts.append(f"Result: {obs.feedback}")
+    return "\n".join(parts)
+
+
+def format_observation_compact(obs):
+    """Compact observation for embedding in completion_ids (~30-60 tokens)."""
+    parts = [f"Stage: {obs.stage}"]
+    if obs.pending_reply:
+        parts.append("PENDING REPLY")
+    if obs.feedback:
+        parts.append(obs.feedback[:200])
+    if obs.discovered_info:
+        parts.append(obs.discovered_info[:200])
+    return "\n".join(parts)
+
+
+def parse_action(text):
+    """Parse LLM output into a RecruitopenenvAction."""
+    text = text.strip()
+
+    # Remove markdown fences
+    if "```" in text:
+        for part in text.split("```"):
+            part = part.strip()
+            if part.startswith("json"):
+                part = part[4:].strip()
+            if part.startswith("{"):
+                text = part
+                break
+
+    # Try JSON
+    try:
+        data = json.loads(text)
+        if isinstance(data, list):
+            data = data[0] if data else {}
+        if isinstance(data, dict) and "tool" in data and "action" in data:
+            return RecruitopenenvAction(
+                tool=data["tool"],
+                action=data["action"],
+                topic=data.get("topic", ""),
+                job_id=int(data.get("job_id", -1)),
+                stage=str(data.get("stage", "")),
+                field=str(data.get("field", "")),
+                value=str(data.get("value", "")),
+            )
+    except (json.JSONDecodeError, KeyError, IndexError, ValueError, TypeError):
+        pass
+
+    # Fallback: try to detect intent
+    text_lower = text.lower()
+    if "read_candidate" in text_lower:
+        return RecruitopenenvAction(tool="crm", action="read_candidate")
+    if "read_reply" in text_lower:
+        return RecruitopenenvAction(tool="messaging", action="read_reply")
+    if "check_approval" in text_lower:
+        return RecruitopenenvAction(tool="approval", action="check_approval")
+    if "wait" in text_lower:
+        return RecruitopenenvAction(tool="workflow", action="wait")
+
+    # Default to reading CRM
+    return RecruitopenenvAction(tool="crm", action="read_candidate")
+
+
+# --- Multi-turn rollout ---
+
+ENV_URL = "http://localhost:8001"
+MAX_COMPLETION_TOKENS = 1536
+
+
+def _build_chat_transition(tokenizer, obs_text):
+    """Build chat-formatted transition tokens: end assistant turn, user obs, start assistant.
+
+    Result: <|im_end|>\n<|im_start|>user\n{obs}<|im_end|>\n<|im_start|>assistant\n
+    This ensures the model sees proper chat structure during the forward pass.
+    """
+    im_start = tokenizer.convert_tokens_to_ids("<|im_start|>")
+    im_end = tokenizer.convert_tokens_to_ids("<|im_end|>")
+
+    # Encode role tags and newlines
+    nl = tokenizer.encode("\n", add_special_tokens=False)
+    user_tag = tokenizer.encode("user", add_special_tokens=False)
+    asst_tag = tokenizer.encode("assistant", add_special_tokens=False)
+    obs_ids = tokenizer.encode(obs_text, add_special_tokens=False)[:60]
+
+    # <|im_end|>\n<|im_start|>user\n{obs}<|im_end|>\n<|im_start|>assistant\n
+    return (
+        [im_end] + nl +
+        [im_start] + user_tag + nl +
+        obs_ids +
+        [im_end] + nl +
+        [im_start] + asst_tag + nl
+    )
+
+
+def rollout_once(trainer, env, tokenizer, prompt_text, system_prompt, max_turns=15):
+    """Run one multi-turn episode with chat-formatted transitions.
+
+    completion_ids: [action1, <|im_end|>user obs<|im_start|>assistant, action2, ...]
+    The chat template structure lets the forward pass assign proper logprobs.
+    """
+    seed = random.randint(0, 2**31 - 1)
+    result = env.reset(seed=seed)
+    obs = result.observation
+
+    prompt_ids = []
+    completion_ids = []
+    logprobs = []
+    env_mask = []
+    total_reward = 0.0
+    steps = 0
+
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": format_observation(obs)},
+    ]
+
+    while not result.done and steps < max_turns:
+        # Check if we're near the token budget (need room for action + transition)
+        if len(completion_ids) > MAX_COMPLETION_TOKENS - 60:
+            break
+
+        current_prompt = tokenizer.apply_chat_template(
+            messages, add_generation_prompt=True, tokenize=False
+        )
+
+        rollout_outputs = generate_rollout_completions(trainer, [current_prompt])[0]
+
+        if steps == 0:
+            prompt_ids = list(rollout_outputs["prompt_ids"])
+
+        action_ids = list(rollout_outputs["completion_ids"])
+        action_logprobs = list(rollout_outputs["logprobs"])
+
+        # Add action tokens (these get gradients)
+        completion_ids.extend(action_ids)
+        logprobs.extend(action_logprobs)
+        env_mask.extend([1] * len(action_ids))
+
+        response = rollout_outputs.get("text") or tokenizer.decode(
+            action_ids, skip_special_tokens=True
+        )
+        messages.append({"role": "assistant", "content": response})
+
+        action = parse_action(response)
+        result = env.step(action)
+        obs = result.observation
+        total_reward += result.reward
+        steps += 1
+
+        if not result.done:
+            # Build chat-formatted transition so forward pass sees proper structure
+            obs_text = format_observation_compact(obs)
+            transition_ids = _build_chat_transition(tokenizer, obs_text)
+
+            completion_ids.extend(transition_ids)
+            logprobs.extend([0.0] * len(transition_ids))
+            env_mask.extend([0] * len(transition_ids))
+
+            messages.append({"role": "user", "content": format_observation(obs)})
+
+    # Truncate to fit max_completion_length
+    completion_ids = completion_ids[:MAX_COMPLETION_TOKENS]
+    logprobs = logprobs[:MAX_COMPLETION_TOKENS]
+    env_mask = env_mask[:MAX_COMPLETION_TOKENS]
+
+    return {
+        "prompt_ids": prompt_ids,
+        "completion_ids": completion_ids,
+        "logprobs": logprobs,
+        "env_mask": env_mask,
+        "env_reward": total_reward,
+        "steps": steps,
+        "final_stage": obs.stage,
+    }
+
+
+def rollout_func(prompts, trainer):
+    """Multi-turn rollout: model controls every action in the episode."""
+    tokenizer = trainer.processing_class
+    env = RecruitopenenvEnv(base_url=ENV_URL)
+
+    all_prompt_ids = []
+    all_completion_ids = []
+    all_logprobs = []
+    all_env_rewards = []
+    all_env_mask = []
+
+    for prompt_text in prompts:
+        episode = rollout_once(trainer, env, tokenizer, prompt_text, SYSTEM_PROMPT)
+
+        if episode["completion_ids"]:
+            all_prompt_ids.append(episode["prompt_ids"])
+            all_completion_ids.append(episode["completion_ids"])
+            all_logprobs.append(episode["logprobs"])
+            all_env_mask.append(episode["env_mask"])
+        else:
+            tok_ids = tokenizer.encode("wait", add_special_tokens=False)
+            all_prompt_ids.append(episode["prompt_ids"] or tok_ids)
+            all_completion_ids.append(tok_ids)
+            all_logprobs.append([0.0] * len(tok_ids))
+            all_env_mask.append([1] * len(tok_ids))
+
+        all_env_rewards.append(episode["env_reward"])
+        print(f"  Episode {len(all_env_rewards)}: reward={episode['env_reward']:.1f}, "
+              f"steps={episode['steps']}, stage={episode['final_stage']}")
+
+    env.close()
+
+    mean_r = sum(all_env_rewards) / len(all_env_rewards)
+    std_r = torch.tensor(all_env_rewards).std().item()
+    print(f"Rollout done: {len(all_env_rewards)} episodes, mean_reward={mean_r:.2f}, std={std_r:.2f}")
+
+    return {
+        "prompt_ids": all_prompt_ids,
+        "completion_ids": all_completion_ids,
+        "logprobs": [[(lp,) for lp in seq] for seq in all_logprobs],
+        "env_reward": all_env_rewards,
+        "env_mask": all_env_mask,
+    }
+
+
+# --- Reward function (fallback, rewards come from rollout) ---
+
+def reward_total(completions, **kwargs):
+    """Extract environment rewards passed via rollout_func kwargs."""
+    env_rewards = kwargs.get("env_reward", [])
+    if env_rewards:
+        return [float(r) for r in env_rewards]
+    return [0.0] * len(completions)
+
+
+# --- Main ---
+
+def main():
+    parser = argparse.ArgumentParser(description="GRPO training for Driver Recruit Environment")
+    parser.add_argument("--model", default="Qwen/Qwen2.5-1.5B-Instruct", help="Model to train")
+    parser.add_argument("--env-url", default="http://localhost:8001", help="Environment server URL")
+    parser.add_argument("--num-episodes", type=int, default=16, help="Number of training episodes (dataset size)")
+    parser.add_argument("--num-generations", type=int, default=4, help="GRPO generations per prompt")
+    parser.add_argument("--batch-size", type=int, default=2, help="Per-device batch size")
+    parser.add_argument("--epochs", type=int, default=1, help="Number of training epochs")
+    parser.add_argument("--lr", type=float, default=5e-5, help="Learning rate")
+    parser.add_argument("--output-dir", default="./recruit-grpo-output", help="Output directory")
+    parser.add_argument("--vllm-mode", default="colocate", choices=["colocate", "server"],
+                        help="vLLM mode: colocate (1 GPU) or server (2+ GPUs)")
+    parser.add_argument("--use-qlora", action="store_true", help="Use QLoRA (4-bit) for memory efficiency")
+    parser.add_argument("--lora-r", type=int, default=16, help="LoRA rank")
+    parser.add_argument("--lora-alpha", type=int, default=32, help="LoRA alpha")
+    args = parser.parse_args()
+
+    global ENV_URL
+    ENV_URL = args.env_url
+
+    tokenizer = AutoTokenizer.from_pretrained(args.model)
+
+    prompts = []
+    env = RecruitopenenvEnv(base_url=args.env_url)
+    for i in range(args.num_episodes):
+        result = env.reset()
+        obs = result.observation
+        user_prompt = format_observation(obs)
+        messages = [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": user_prompt},
+        ]
+        prompt_text = tokenizer.apply_chat_template(
+            messages, add_generation_prompt=True, tokenize=False
+        )
+        prompts.append(prompt_text)
+    env.close()
+
+    dataset = Dataset.from_dict({"prompt": prompts})
+
+    peft_config = None
+    model_kwargs = {}
+    if args.use_qlora:
+        from peft import LoraConfig
+        peft_config = LoraConfig(
+            r=args.lora_r,
+            lora_alpha=args.lora_alpha,
+            lora_dropout=0.05,
+            target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
+                            "gate_proj", "up_proj", "down_proj"],
+            task_type="CAUSAL_LM",
+        )
+        model_kwargs["quantization_config"] = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_compute_dtype=torch.bfloat16,
+            bnb_4bit_quant_type="nf4",
+        )
+        print(f"Using QLoRA: r={args.lora_r}, alpha={args.lora_alpha}, 4-bit")
+
+    grpo_config = GRPOConfig(
+        output_dir=args.output_dir,
+        use_vllm=True,
+        vllm_mode=args.vllm_mode,
+        num_train_epochs=args.epochs,
+        num_generations=args.num_generations,
+        max_completion_length=1536,
+        per_device_train_batch_size=args.batch_size,
+        gradient_accumulation_steps=4,
+        gradient_checkpointing=True,
+        learning_rate=args.lr,
+        temperature=0.7,
+        logging_steps=1,
+        save_steps=50,
+        bf16=True,
+        report_to="wandb",
+        run_name="recruit-grpo-tools",
+        model_init_kwargs=model_kwargs if model_kwargs else None,
+    )
+
+    trainer_kwargs = dict(
+        model=args.model,
+        processing_class=tokenizer,
+        reward_funcs=[reward_total],
+        train_dataset=dataset,
+        args=grpo_config,
+        rollout_func=rollout_func,
+    )
+    if peft_config is not None:
+        trainer_kwargs["peft_config"] = peft_config
+
+    trainer = GRPOTrainer(**trainer_kwargs)
+
+    print("=" * 50)
+    print(f"Training {args.model} (TOOL-BASED MULTI-TURN)")
+    print(f"Environment: {args.env_url}")
+    print(f"QLoRA: {args.use_qlora}")
+    print(f"Episodes: {args.num_episodes}")
+    print(f"Epochs: {args.epochs}")
+    print(f"Generations per prompt: {args.num_generations}")
+    print("=" * 50)
+
+    trainer.train()
+    trainer.save_model(args.output_dir)
+    print(f"\nModel saved to {args.output_dir}")
+
+
+if __name__ == "__main__":
+    main()