File size: 5,905 Bytes
99e41a8
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
"""Engineered planner: prompt spec + few-shot + scene-grounded validator + repair loop.

No model changes — pure engineering around any chat LLM:
  1. a precise skill specification and worked examples (removes systematic errors such as
     'move the tower base to the table first')
  2. a symbolic, scene-grounded validator that simulates the plan (object/location grounding,
     only-move-what-was-asked, drawer open/closed state) and returns precise error messages
  3. a repair loop that feeds those errors back to the model (max `repairs` rounds)
"""
from __future__ import annotations

import json
import re

from robotics.planner.canon import _loc, canon_str
from robotics.planner.task_planner import SKILLS, PlanError, parse_plan

SPEC = """You are the task planner for a single robot arm on a tabletop.
Skills (use ONLY these; JSON fields in brackets):
  pick   [object]            grasp an object (optional: place/stack grasp automatically)
  place  [object, location]  put the object in/on a container or another object
  stack  [object, location]  put a cube on top of another cube
  open   [object]            open a drawer (required before putting anything in it)
  close  [object]            close a drawer
  push   [object, location]  push an object somewhere
  home   []                  return the arm to rest
Rules:
  - Objects and locations must be EXACT names from the scene list.
  - Move ONLY objects the instruction requires. Never move anything to 'table', 'center',
    'home' or any location not in the scene. The bottom cube of a tower stays where it is.
  - Respect the order the instruction gives ("first ... then ...").
  - If the instruction needs an object that is not in the scene, or an ability outside these
    skills (cutting, painting, throwing, leaving the table...), return
    {"steps": [], "infeasible_reason": "<why>"}.
Respond with JSON only: {"steps": [{"skill": ..., "object": ..., "location": ...}]}"""

FEWSHOT = [
    ({"scene": ["red cube", "green cube", "blue cube", "white box"],
      "instr": "make a stack: green on the bottom, then blue, then red on top"},
     {"steps": [{"skill": "stack", "object": "blue cube", "location": "green cube"},
                {"skill": "stack", "object": "red cube", "location": "blue cube"}]}),
    ({"scene": ["yellow cube", "red cube", "drawer"], "instr": "put the red cube away in the drawer and close it"},
     {"steps": [{"skill": "open", "object": "drawer"},
                {"skill": "place", "object": "red cube", "location": "drawer"},
                {"skill": "close", "object": "drawer"}]}),
    ({"scene": ["red cube", "blue bowl"], "instr": "put the orange cube in the bowl"},
     {"steps": [], "infeasible_reason": "there is no orange cube in the scene"}),
]


def messages(scene, instr, extra_system=""):
    msgs = [{"role": "system", "content": SPEC + extra_system}]
    for q, a in FEWSHOT:
        msgs += [{"role": "user", "content": f"Scene objects: {q['scene']}\nInstruction: {q['instr']}"},
                 {"role": "assistant", "content": json.dumps(a)}]
    msgs.append({"role": "user", "content": f"Scene objects: {scene}\nInstruction: {instr}"})
    return msgs


def validate(plan, scene, instr) -> list[str]:
    """Symbolic, scene-grounded checks. Returns a list of error strings (empty = ok)."""
    errs = []
    names = {s.lower() for s in scene}
    text = instr.lower()
    # quantified instructions ("every cube", "all the cubes", "both") legitimately move objects
    # that are never named, so the only-move-what-was-asked check must not apply to them
    quantified = re.search(r"\b(every|all|each|both|everything|remaining|rest)\b", text) is not None
    drawer_open = False
    for i, s in enumerate(plan.steps, 1):
        obj = (s.object or "").lower().strip()
        loc = _loc(s.location)
        if obj and obj not in names:
            errs.append(f"step {i}: object '{s.object}' is not in the scene")
        if s.skill in ("place", "stack", "push"):
            if not loc:
                errs.append(f"step {i}: '{s.skill}' needs a location")
            elif loc not in names:
                errs.append(f"step {i}: location '{s.location}' is not a scene object; use one of {sorted(names)}")
            elif loc == obj:
                errs.append(f"step {i}: cannot put '{obj}' on itself")
        if s.skill in ("pick", "place", "stack", "push") and obj and obj in names and not quantified:
            head = obj.split()[0]
            if obj not in text and not re.search(rf"\b{re.escape(head)}\b", text):
                errs.append(f"step {i}: the instruction never asks to move '{obj}'")
        if s.skill == "open" and obj == "drawer":
            drawer_open = True
        if s.skill == "close" and obj == "drawer":
            drawer_open = False
        if s.skill in ("place", "push") and loc == "drawer" and not drawer_open:
            errs.append(f"step {i}: the drawer must be opened before putting something in it")
    return errs


def plan_engineered(chat_fn, scene, instr, repairs=2, extra_system=""):
    """Returns (canonical answer, n_llm_calls, raw_last)."""
    msgs = messages(scene, instr, extra_system)
    calls, raw = 0, ""
    for attempt in range(repairs + 1):
        raw, _ = chat_fn(msgs)
        calls += 1
        try:
            p = parse_plan(raw, None)
            errs = validate(p, scene, instr)
        except PlanError as e:
            p, errs = None, [str(e)]
        if not errs or attempt == repairs:
            if p is None:
                return f"INVALID:{errs[0][:40]}", calls, raw
            return canon_str(p.steps), calls, raw
        msgs = msgs + [{"role": "assistant", "content": raw},
                       {"role": "user", "content": "Your plan has errors:\n- " + "\n- ".join(errs)
                        + "\nReturn the corrected JSON plan only."}]
    return "INVALID", calls, raw