RoboRACE-Bench / src /robotics /planner /task_planner.py
Nabidnur's picture
RoboRACE: code, cached agent outputs, results, media, SO-101 renders (part 5)
99e41a8 verified
Raw History Blame Contribute Delete
4.43 kB
"""High-level task planner: natural-language instruction -> validated skill plan.
The LLM may only use skills from SKILLS; each step becomes a short language
instruction for the low-level VLA (GR00T N1.7 / SmolVLA), which is the format
those policies were trained on.
"""
from __future__ import annotations
import json
import re
from dataclasses import dataclass, field
from typing import Callable
# Skills the low-level policy has been fine-tuned on. Extend as datasets grow.
SKILLS: dict[str, str] = {
"pick": "pick up {object}",
"place": "place the {object} {location}",
"push": "push the {object} {location}",
"open": "open the {object}",
"close": "close the {object}",
"stack": "stack the {object} on the {location}",
"home": "move the arm to the home position",
}
SYSTEM_PROMPT = """You are the task planner for a single robot arm.
Decompose the user's instruction into a short sequence of skills.
Allowed skills (use ONLY these): {skills}.
Each step needs "skill"; "object" and "location" when the skill uses them.
Only reference objects listed in the scene. If the task is impossible with
these skills or objects, return {{"steps": [], "infeasible_reason": "..."}}.
Respond with JSON only: {{"steps": [{{"skill": ..., "object": ..., "location": ...}}]}}"""
@dataclass
class Step:
skill: str
object: str | None = None
location: str | None = None
def instruction(self) -> str:
tmpl = SKILLS[self.skill]
return tmpl.format(object=self.object or "", location=self.location or "").strip()
@dataclass
class Plan:
steps: list[Step] = field(default_factory=list)
infeasible_reason: str | None = None
provider: str | None = None
class PlanError(ValueError):
pass
def _extract_json(text: str) -> dict:
text = text.strip()
fence = re.search(r"```(?:json)?\s*(.*?)```", text, re.S)
if fence:
text = fence.group(1)
start, end = text.find("{"), text.rfind("}")
if start < 0 or end < start:
raise PlanError("no JSON object in LLM output")
try:
return json.loads(text[start : end + 1])
except json.JSONDecodeError as e:
raise PlanError(f"invalid JSON: {e}") from e
def parse_plan(text: str, scene_objects: list[str] | None = None, max_steps: int = 12) -> Plan:
data = _extract_json(text)
raw = data.get("steps")
if not isinstance(raw, list):
raise PlanError("'steps' must be a list")
if len(raw) > max_steps:
raise PlanError(f"plan too long ({len(raw)} > {max_steps})")
known = {o.lower() for o in scene_objects} if scene_objects else None
steps: list[Step] = []
for i, s in enumerate(raw):
if not isinstance(s, dict) or s.get("skill") not in SKILLS:
raise PlanError(f"step {i}: unknown skill {s!r}")
step = Step(s["skill"], s.get("object") or None, s.get("location") or None)
if "{object}" in SKILLS[step.skill] and not step.object:
raise PlanError(f"step {i}: skill '{step.skill}' needs an object")
if known is not None and step.object and step.object.lower() not in known:
raise PlanError(f"step {i}: object '{step.object}' not in scene")
steps.append(step)
return Plan(steps=steps, infeasible_reason=data.get("infeasible_reason"))
def plan(
instruction: str,
scene_objects: list[str],
chat_fn: Callable[..., tuple[str, str]] | None = None,
max_attempts: int = 3,
) -> Plan:
"""Ask the LLM for a plan; on validation failure, feed the error back and retry."""
if chat_fn is None:
from robotics.llm.providers import chat as chat_fn # lazy: keeps tests offline
messages = [
{"role": "system", "content": SYSTEM_PROMPT.format(skills=", ".join(SKILLS))},
{"role": "user", "content": f"Scene objects: {scene_objects}\nInstruction: {instruction}"},
]
last_err: Exception | None = None
for _ in range(max_attempts):
text, provider = chat_fn(messages, json_mode=True)
try:
p = parse_plan(text, scene_objects)
p.provider = provider
return p
except PlanError as e:
last_err = e
messages += [{"role": "assistant", "content": text},
{"role": "user", "content": f"Invalid plan: {e}. Return corrected JSON only."}]
raise PlanError(f"no valid plan after {max_attempts} attempts: {last_err}")