Move system prompt from agent_sdk/ to abstraction learning approach

The system prompt and iteration message builder were only used by
AgentAbstractionLearningApproach, so move them into that file and
delete the standalone module.

Author: yichao-liang

predicators/agent_sdk/system_prompt.py

@@ -15,8 +15,6 @@
 from predicators import utils
 from predicators.agent_sdk.proposal_parser import ProposalBundle, \
     build_exec_context, exec_code_safely
-from predicators.agent_sdk.system_prompt import build_iteration_message, \
-    build_system_prompt
 from predicators.approaches.agent_planner_approach import AgentPlannerApproach
 from predicators.approaches.agent_session_mixin import AgentSessionMixin
 from predicators.approaches.pp_online_process_learning_approach import \
@@ -87,11 +85,8 @@ def _get_log_dir(self) -> str:
         """Use the mixin's simple log dir (no run_id subdirectory)."""
         return AgentSessionMixin._get_log_dir(self)
 
-    def _get_agent_model_name(self) -> str:
-        return CFG.agent_sdk_model_name
-
     def _get_agent_system_prompt(self) -> str:
-        return build_system_prompt()
+        return _SYSTEM_PROMPT
 
     # ------------------------------------------------------------------ #
     # Overridable helpers (from AgentPlannerApproach)
@@ -666,3 +661,174 @@ def load(self, online_learning_cycle: Optional[int] = None) -> None:
             f"{len(self._learned_predicates)} learned predicates, "
             f"{len(self._offline_dataset.trajectories)} offline trajectories, "
             f"{len(self._online_dataset.trajectories)} online trajectories")
+
+
+# ------------------------------------------------------------------ #
+# Prompt helpers (abstraction-learning specific)
+# ------------------------------------------------------------------ #
+
+_SYSTEM_PROMPT = """\
+You are an abstraction inventor for a bilevel process planning system. Your \
+role is to propose types, predicates, helper objects, processes, and options \
+that help a task planner solve planning problems.
+
+## What You Observe
+
+You observe the world ONLY through:
+- **Trajectory data**: sequences of states (feature vectors per object) and \
+actions
+- **Task goals**: symbolic goal descriptions
+- **Planning metrics**: success rate, nodes expanded, failure reasons
+- **Current abstractions**: the types, predicates, processes, and options \
+currently in use
+
+You do NOT have access to environment source code, simulator internals, or \
+ground-truth models. You must infer useful abstractions from observed data.
+
+## What You Can Propose
+
+1. **Types**: New object types with named features
+2. **Predicates**: Boolean classifiers over states and objects
+3. **Helper Objects / Task Augmentation**: Functions that add helper objects \
+to tasks (e.g., grid locations, reference frames)
+4. **Processes**: Causal processes (exogenous events triggered by conditions)
+5. **Options**: Parameterized actions
+
+## Code Conventions
+
+When writing proposal code, the following variables are available in the exec \
+context:
+
+### Imports (already available — no need to import)
+- `np`, `numpy`, `torch`
+- `Box` (from gym.spaces)
+- `Type`, `Predicate`, `DerivedPredicate`, `NSPredicate`
+- `Object`, `Variable`, `LiftedAtom`, `GroundAtom`
+- `ExogenousProcess`, `EndogenousProcess`, `CausalProcess`
+- `ParameterizedOption`, `State`, `Task`
+- `ConstantDelay`, `DiscreteGaussianDelay`
+- `List`, `Set`, `Sequence` (from typing)
+
+### Current abstractions
+- Each type `T` is available as `T_type` (e.g., `domino_type`, `robot_type`)
+- Each predicate `P` is available by name (e.g., `Fallen`, `Standing`)
+- Each predicate classifier is available as `_P_holds` \
+(e.g., `_Fallen_holds`)
+- Each option `O` is available by name (e.g., `Push`)
+
+### Expected output variables per proposal tool
+- `propose_types`: must define `proposed_types` (a list of Type objects)
+- `propose_predicates`: must define `proposed_predicates` \
+(a list of Predicate objects)
+- `propose_object_augmentor`: must define `augment_task(task) -> Task`
+- `propose_processes`: must define `proposed_processes` \
+(a list of CausalProcess objects)
+- `propose_options`: must define `proposed_options` \
+(a list of ParameterizedOption objects)
+
+## Key API Reference
+
+### State
+```python
+state.get(obj, "feature_name")  # get a feature value
+state.set(obj, "feature_name", value)  # set a feature value
+state.get_objects(some_type)  # get all objects of a type
+list(state)  # iterate over all objects
+state.copy()  # copy the state
+```
+
+### Predicate
+```python
+pred = Predicate("MyPred", [type1_type, type2_type],
+                 lambda state, objects: state.get(objects[0], "feat") > 0.5)
+pred.holds(state, [obj1, obj2])  # evaluate
+```
+
+### Process (ExogenousProcess)
+```python
+v1 = Variable("?x", some_type)
+v2 = Variable("?y", other_type)
+proc = ExogenousProcess(
+    name="MyProcess",
+    parameters=[v1, v2],
+    condition_at_start={LiftedAtom(SomePred, [v1, v2])},
+    condition_overall={LiftedAtom(SomePred, [v1, v2])},
+    condition_at_end=set(),
+    add_effects={LiftedAtom(ResultPred, [v1])},
+    delete_effects=set(),
+    delay_distribution=ConstantDelay(1),
+    strength=torch.tensor([1.0]),
+)
+```
+
+### Type
+```python
+my_type = Type("my_type", ["feature1", "feature2"])
+```
+
+## Iteration Protocol
+
+At each learning iteration:
+1. **Inspect** the trajectory data and planning results using inspection tools
+2. **Form hypotheses** about what abstractions are missing or insufficient
+3. **Propose** new abstractions using proposal tools
+4. **Test** your proposals using testing tools
+5. **Refine** based on test results - fix errors and retry
+
+Focus on proposing abstractions that will help the planner solve more tasks. \
+Pay attention to:
+- States where planning fails - what conditions are missing?
+- Patterns in trajectory data that aren't captured by current predicates
+- Whether helper objects (like grid positions) could simplify the problem
+"""
+
+
+def build_iteration_message(cycle: int,
+                            num_new_trajs: int,
+                            num_total_trajs: int,
+                            task_success_rate: float,
+                            type_names_with_features: str,
+                            predicate_signatures: str,
+                            num_predicates: int,
+                            process_summaries: str,
+                            num_processes: int,
+                            option_names: str,
+                            num_options: int,
+                            planning_success: str,
+                            avg_nodes: str,
+                            failure_summaries: str,
+                            previous_iteration_outcomes: str,
+                            available_tools: Optional[List[Any]] = None) -> str:
+    """Build the message sent to the agent at each iteration."""
+    tools_section = ""
+    if available_tools:
+        tool_list = "\n".join(f"  - {t}" for t in available_tools)
+        tools_section = f"\nAVAILABLE TOOLS:\n{tool_list}\n"
+
+    return f"""\
+== Online Learning Iteration {cycle} ==
+
+TRAJECTORY SUMMARY:
+- {num_new_trajs} new trajectories collected this cycle
+- {num_total_trajs} total trajectories (offline + online)
+- Task success rate: {task_success_rate:.1%}
+
+CURRENT ABSTRACTIONS:
+- Types: {type_names_with_features}
+- Predicates ({num_predicates}): {predicate_signatures}
+- Processes ({num_processes}): {process_summaries}
+- Options ({num_options}): {option_names}
+
+PLANNING PERFORMANCE:
+{planning_success}
+- Avg nodes expanded: {avg_nodes}
+- Failures: {failure_summaries}
+
+PREVIOUS ITERATION OUTCOMES:
+{previous_iteration_outcomes}
+{tools_section}
+YOUR TASK:
+Inspect the trajectory data and planning results. Propose new or improved \
+abstractions that will help the planner solve more tasks. Use the proposal \
+tools to register your proposals and the testing tools to validate them.
+"""