plancraft 0.4.2__py3-none-any.whl → 0.4.4__py3-none-any.whl

plancraft/environment/env.py

@@ -323,12 +323,11 @@ class PlancraftEnvironment:
         # not enough
         if self.slot_empty(slot_from) or self.state[slot_from]["quantity"] < quantity:
             return
-        # if craft slot - must take all
+        # if craft slot - move takes all
         if slot_from == 0 and self.state[slot_from]["quantity"] != quantity:
-            return
+            quantity = self.state[slot_from]["quantity"]
 
         item = self.state[slot_from]
-
         # slot to is not empty or is the same type as item
         if self.slot_empty(slot_to):
             # add quantity to new slot

plancraft/environment/planner.py

@@ -234,11 +234,13 @@ def get_plan(observation: dict):
 
 def decompose_subgoal(
     current_inventory: dict, plan_recipe, new_inventory: dict[str, int]
-) -> list[str]:
+) -> tuple[list[str], dict[str, int], list[str]]:
     """
     For a given plan_recipe and inventory, output the list of action to craft recipe
     """
     subplan = []
+    # track the item type used in each action's from_slot
+    action_items_used = []
     new_inventory_counter = Counter(new_inventory)
     current_inventory_counter = get_inventory_counter(current_inventory)
     items_to_use_counter = current_inventory_counter - new_inventory_counter
@@ -264,6 +266,7 @@ def decompose_subgoal(
             action = SmeltAction(
                 slot_from=from_slot, slot_to=free_slot, quantity=quantity
             )
+            action_items_used.append(current_inventory[from_slot]["type"])
             subplan.append(str(action))
 
             # update inventory to decrement quantity of item in from_slot and increment quantity of item in free_slot
@@ -280,7 +283,7 @@ def decompose_subgoal(
             if current_inventory[from_slot]["quantity"] <= 0:
                 del current_inventory[from_slot]
 
-            return subplan, current_inventory
+            return subplan, current_inventory, action_items_used
 
     elif isinstance(plan_recipe, ShapelessRecipe):
         crafting_slot = 1
@@ -314,6 +317,7 @@ def decompose_subgoal(
                         slot_to=free_slot,
                         quantity=current_inventory[crafting_slot]["quantity"],
                     )
+                    action_items_used.append(current_inventory[crafting_slot]["type"])
                     subplan.append(str(action))
                     current_inventory = update_inventory(
                         current_inventory,
@@ -331,6 +335,7 @@ def decompose_subgoal(
                 action = MoveAction(
                     slot_from=from_slot, slot_to=crafting_slot, quantity=1
                 )
+                action_items_used.append(current_inventory[from_slot]["type"])
                 subplan.append(str(action))
                 current_inventory = update_inventory(
                     current_inventory, from_slot, crafting_slot, 1
@@ -366,6 +371,9 @@ def decompose_subgoal(
                         slot_to=free_slot,
                         quantity=current_inventory[inventory_position]["quantity"],
                     )
+                    action_items_used.append(
+                        current_inventory[inventory_position]["type"]
+                    )
                     current_inventory = update_inventory(
                         current_inventory,
                         inventory_position,
@@ -411,6 +419,9 @@ def decompose_subgoal(
                                     "quantity"
                                 ],
                             )
+                            action_items_used.append(
+                                current_inventory[inventory_position]["type"]
+                            )
                             current_inventory = update_inventory(
                                 current_inventory,
                                 inventory_position,
@@ -428,6 +439,7 @@ def decompose_subgoal(
                             slot_to=inventory_position,
                             quantity=1,
                         )
+                        action_items_used.append(current_inventory[from_slot]["type"])
                         items_to_use_counter[item] -= 1
                         added_item = True
                         # update state of inventory
@@ -446,6 +458,7 @@ def decompose_subgoal(
                     slot_to=free_slot,
                     quantity=current_inventory[slot]["quantity"],
                 )
+                action_items_used.append(current_inventory[slot]["type"])
                 current_inventory = update_inventory(
                     current_inventory,
                     slot,
@@ -469,6 +482,7 @@ def decompose_subgoal(
             )
         )
     )
+    action_items_used.append(current_inventory[0]["type"])
     current_inventory = update_inventory(
         current_inventory, 0, free_slot, plan_recipe.result.count
     )
@@ -479,10 +493,10 @@ def decompose_subgoal(
             if current_inventory[i]["quantity"] <= 0:
                 del current_inventory[i]
 
-    return subplan, current_inventory
+    return subplan, current_inventory, action_items_used
 
 
-def get_subplans(observation: dict) -> tuple[list[list[str]], list]:
+def get_subplans(observation: dict, return_items=False) -> tuple[list[list[str]], list]:
     current_inventory = copy.deepcopy(observation["inventory"])
     plan = get_plan(observation)
     # get action
@@ -490,10 +504,15 @@ def get_subplans(observation: dict) -> tuple[list[list[str]], list]:
         return [[str(StopAction())]], []
     # plan_recipe, new_inventory = plan[0]
     subplans = []
+    action_items_used = []
+
     # Calculate the subplans for each step in the plan
     for plan_recipe, new_inventory in plan:
-        subplan, current_inventory = decompose_subgoal(
+        subplan, current_inventory, action_items = decompose_subgoal(
             current_inventory, plan_recipe, new_inventory
         )
         subplans.append(subplan)
+        action_items_used.append(action_items)
+    if return_items:
+        return subplans, plan, action_items_used
     return subplans, plan

plancraft/environment/sampler.py

@@ -110,17 +110,21 @@ def sample_recipes(
     return start_inputs, overall_exclude_set
 
 
-def remove_ancestor_items(target: str, inventory: dict[str, int]) -> dict[str, int]:
+def remove_ancestor_items(
+    target: str, inventory: dict[str, int]
+) -> tuple[dict[str, int], list[tuple[str, int]]]:
     ancestors = set(get_ancestors(target))
     possible_items = set(inventory.keys())
     items_to_remove = list(ancestors.intersection(possible_items))
     num_items = random.randint(1, len(items_to_remove))
+    removed_items = []
     for item in random.sample(items_to_remove, num_items):
         count_to_remove = random.randint(1, inventory[item])
         inventory[item] -= count_to_remove
         if inventory[item] == 0:
             del inventory[item]
-    return inventory
+        removed_items.append((item, count_to_remove))
+    return inventory, removed_items
 
 
 def construct_example(
@@ -142,9 +146,10 @@ def construct_example(
 
     # sample the recipe
     inventory, overall_exclude_set = sample_recipes(target, set())
+    removed_items = []
     if impossible:
         # if impossible then remove one or more items from the inventory
-        inventory = remove_ancestor_items(
+        inventory, removed_items = remove_ancestor_items(
             target,
             inventory,
         )
@@ -158,7 +163,7 @@ def construct_example(
     while (optimal_path is not None and impossible) or (
         optimal_path is None and not impossible
     ):
-        inventory = remove_ancestor_items(target, inventory)
+        inventory, removed_items = remove_ancestor_items(target, inventory)
         optimal_path = optimal_planner(target, inventory)
 
     # assign to slots
@@ -169,6 +174,7 @@ def construct_example(
         "target": target,
         "num_distractors": num_distractors,
         "impossible": impossible,
+        "missing_items": removed_items,
     }
     # either impossible and no path or not impossible and path exists
     assert (impossible and optimal_path is None) or (

plancraft/mcp.py

@@ -0,0 +1,429 @@
+import base64
+import csv
+import os
+import random
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from dataclasses import dataclass, field
+from typing import Any, Literal, Optional
+
+from loguru import logger
+from PIL import Image as PILImage
+from plancraft.config import PlancraftExample
+from plancraft.environment.actions import (
+    MoveAction,
+    SmeltAction,
+    StopAction,
+)
+from plancraft.environment.env import (
+    PlancraftEnvironment,
+    get_objective_str,
+    target_and_inventory_to_text_obs,
+)
+from plancraft.simple import get_plancraft_examples
+
+from mcp.server.fastmcp import Context, FastMCP
+from mcp.types import CallToolResult, ImageContent, TextContent
+
+
+class PlancraftMCPWrapper:
+    def __init__(
+        self,
+        example: PlancraftExample,
+        max_steps: int = 30,
+        resolution: str = "high",
+        use_text_inventory: bool = True,
+    ):
+        self.max_steps = max_steps
+        # whether to convert the inventory to text observation
+        # if False, only the objective string is returned
+        self.use_text_inventory = use_text_inventory
+        self.current_step = 0
+        self.stopped = False
+        self.success = False
+        self.example = example
+        self.resolution = resolution
+        self.environment = PlancraftEnvironment(
+            example.slotted_inventory, resolution=self.resolution
+        )
+
+    def check_done(self, inventory: dict, target: str):
+        """
+        Check that target object is obtained
+        """
+        for slot, item in inventory.items():
+            # ensure the target is in the inventory (not in slot 0)
+            if target == item["type"] and slot != 0:
+                return True
+        return False
+
+    def step(
+        self, action: Optional[StopAction | MoveAction | SmeltAction] = None
+    ) -> tuple[dict[str, Any], bool]:
+        # Handle already stopped case
+        if self.stopped:
+            return (
+                {"text": "Plancraft environment is terminated"},
+                True,
+            )
+
+        # Handle initial step
+        if not action:
+            observation = self.environment.step()
+            observation["target"] = self.example.target
+            if self.use_text_inventory:
+                text = target_and_inventory_to_text_obs(
+                    target=self.example.target, inventory=observation["inventory"]
+                )
+            else:
+                text = get_objective_str(self.example.target)
+            observation["text"] = text
+            return observation, self.stopped
+
+        # Handle max steps reached
+        if self.current_step > self.max_steps:
+            self.stopped = True
+            return (
+                {"text": f"Max steps ({self.max_steps}) reached"},
+                self.stopped,
+            )
+
+        self.current_step += 1
+        # Handle stop action
+        if isinstance(action, StopAction):
+            self.stopped = True
+            #  success is True if example was truly impossible
+            self.success = self.example.impossible
+            observation = {
+                "text": "Plancraft environment is terminate due to stop action"
+            }
+        else:
+            observation = self.environment.step(action)
+            observation["target"] = self.example.target
+
+            # Generate text observation
+            if self.use_text_inventory:
+                text = target_and_inventory_to_text_obs(
+                    target=self.example.target, inventory=observation["inventory"]
+                )
+            else:
+                text = get_objective_str(self.example.target)
+
+            observation["text"] = text
+
+            self.success = self.check_done(
+                observation["inventory"], self.example.target
+            )
+
+        return (
+            observation,
+            self.stopped,
+        )
+
+
+@dataclass
+class PlancraftContext:
+    """Context for the Plancraft environment."""
+
+    env: Optional[Any] = None
+    examples: list[PlancraftExample] = field(default_factory=list)
+
+    # Default environment settings
+    max_steps: int = 30
+    resolution: Literal["high", "low"] = "high"
+    use_text_inventory: bool = True
+    terminated: bool = False
+    use_images: bool = False
+
+    # history and statistics
+    history: list[dict] = field(default_factory=list)
+
+
+@asynccontextmanager
+async def app_lifespan(server: FastMCP) -> AsyncIterator[PlancraftContext]:
+    """Manage application lifecycle with type-safe context"""
+    # Initialize on startup
+    try:
+        logger.info("Starting up")
+        examples = get_plancraft_examples(split="train")
+        yield PlancraftContext(examples=examples)
+    finally:
+        # Cleanup on shutdown
+        logger.info("Shutting down")
+
+
+# Pass lifespan to server
+app = FastMCP("Plancraft", lifespan=app_lifespan)
+
+
+@app.prompt()
+def plancraft_environment_instructions() -> str:
+    return """You are crafting in Minecraft. You need to decide on the next action.
+
+Crafting Grid: The crafting table is organized into a 3x3 grid. Each slot in the grid has a unique identifier:
+    - Top row: [A1] [A2] [A3]
+    - Middle row: [B1] [B2] [B3]
+    - Bottom row: [C1] [C2] [C3]
+
+The output of the crafting process is placed in a designated output slot labeled [0] You cannot move or smelt items directly into slot [0]
+
+Inventory Slots: The remaining inventory slots (outside of the crafting grid) are used for storing items. These slots are labeled as [I1] to [I36]
+
+Constraints:
+   - You cannot move or smelt items into [0]
+   - If an item is not in slot [0] then the recipe is incorrect
+   - You need to move items from [0] to a free inventory slot to complete the crafting process"""
+
+
+def observation_to_tool_result(
+    observation: dict,
+    terminated: bool = False,
+    success: bool = False,
+    add_instructions=False,
+    use_images=False,
+) -> CallToolResult:
+    content = []
+    if add_instructions:
+        instructions = plancraft_environment_instructions()
+        content.append(TextContent(text=instructions, type="text"))
+
+    text_content = observation["text"]
+    # Add success message if the task was completed successfully
+    if success:
+        text_content = f"SUCCESS! You have completed the task: {text_content}"
+    # Add termination message if the task was terminated but not successful
+    elif terminated:
+        text_content = f"Task terminated: {text_content}"
+
+    content.append(TextContent(text=text_content, type="text"))
+
+    if use_images:
+        # numpy array to PIL
+        pil_image = PILImage.fromarray(observation["image"])
+        # Save the image to a BytesIO buffer in PNG format
+        import io
+
+        buffer = io.BytesIO()
+        pil_image.save(buffer, format="PNG")
+        buffer.seek(0)
+
+        # Encode the properly formatted PNG data
+        base64_data = base64.b64encode(buffer.getvalue()).decode("utf-8")
+        content.append(
+            ImageContent(type="image", data=base64_data, mimeType="image/png")
+        )
+    return CallToolResult(
+        content=content,
+    )
+
+
+def add_action_to_history(
+    action: MoveAction | SmeltAction | StopAction, result: CallToolResult, ctx: Context
+) -> None:
+    """Add action call to history - storing only text content for simplicity"""
+    # Extract only the text content from the result
+    text_content = ""
+    for content in result.content:
+        if hasattr(content, "text"):
+            text_content = content.text
+            break
+    ctx.request_context.lifespan_context.history.append(
+        {"action": str(action), "observation": text_content}
+    )
+
+
+def save_result_if_terminated(environment, terminated: bool, ctx: Context) -> None:
+    """Helper function to save results if the environment is terminated"""
+    if terminated:
+        logger.info(f"Task completed or terminated in {environment.current_step} steps")
+
+        result_data = {
+            "example_id": environment.example.id,
+            "success": environment.success,
+            "steps": environment.current_step,
+            "history": ctx.request_context.lifespan_context.history.copy(),
+        }
+
+        # save the result data to a CSV file
+        pwd = os.path.dirname(os.path.abspath(__file__))
+        os.makedirs("results", exist_ok=True)
+        result_file = os.path.join(pwd, "results", "results.csv")
+        with open(result_file, mode="a", newline="") as f:
+            writer = csv.DictWriter(f, fieldnames=result_data.keys())
+            if f.tell() == 0:
+                writer.writeheader()
+            writer.writerow(result_data)
+
+        # Reset history after storing results
+        ctx.request_context.lifespan_context.history = []
+
+
+def correct_slot_format(slot: str):
+    # helper function to correct the slot format
+    # Claude seems unable to generate slots with brackets
+    if "[" not in slot and "]" not in slot:
+        return f"[{slot}]"
+
+
+@app.tool(
+    name="smelt",
+    description="Smelt items in the Plancraft environment. You must specify the slot to smelt from and the slot to smelt to and quantity.",
+)
+def smelt(from_slot: str, to_slot: str, quantity: int, ctx: Context) -> CallToolResult:
+    """Smelt items in the Plancraft environment. You must specify the slot to smelt from and the slot to smelt to and quantity."""
+    try:
+        environment = ctx.request_context.lifespan_context.env
+        use_images = ctx.request_context.lifespan_context.use_images
+
+        if environment.stopped:
+            content = "Plancraft environment is terminated, first call start_new_task to start a new task"
+            return CallToolResult(
+                content=[TextContent(text=content, type="text")], isError=True
+            )
+
+        smelt_action = SmeltAction(
+            slot_from=correct_slot_format(from_slot),
+            slot_to=correct_slot_format(to_slot),
+            quantity=quantity,
+        )
+        obs, terminated = environment.step(smelt_action)
+
+        # Generate the result with appropriate success/termination messages
+        result = observation_to_tool_result(
+            obs,
+            terminated=terminated,
+            success=environment.success,
+            use_images=use_images,
+        )
+        add_action_to_history(smelt_action, result, ctx)
+        logger.info(f"Step {environment.current_step}: {obs['text']}")
+
+        # Save result if the task is terminated
+        save_result_if_terminated(environment, terminated, ctx)
+
+        return result
+    except Exception as e:
+        return CallToolResult(
+            content=[TextContent(text=str(e), type="text")], isError=True
+        )
+
+
+@app.tool(
+    name="move",
+    description="Move items in the Plancraft environment. You must specify the slot to move from and the slot to move to and quantity.",
+)
+def move(from_slot: str, to_slot: str, quantity: int, ctx: Context) -> CallToolResult:
+    """
+    Move items in the Plancraft environment. You must specify the slot to move from and the slot to move to and quantity.
+    """
+    try:
+        environment = ctx.request_context.lifespan_context.env
+        use_images = ctx.request_context.lifespan_context.use_images
+        if environment.stopped:
+            content = "Plancraft environment is terminated, first call start_new_task to start a new task"
+            return CallToolResult(
+                content=[TextContent(text=content, type="text")], isError=True
+            )
+
+        move_action = MoveAction(
+            slot_from=correct_slot_format(from_slot),
+            slot_to=correct_slot_format(to_slot),
+            quantity=quantity,
+        )
+        obs, terminated = environment.step(move_action)
+
+        # Generresult with appropriate success/termination messages
+        result = observation_to_tool_result(
+            obs,
+            terminated=terminated,
+            success=environment.success,
+            use_images=use_images,
+        )
+        add_action_to_history(move_action, result, ctx)
+        logger.info(f"Step {environment.current_step}: {obs['text']}")
+
+        # Save result if the task is terminated
+        save_result_if_terminated(environment, terminated, ctx)
+
+        return result
+
+    except Exception as e:
+        return CallToolResult(
+            content=[TextContent(text=str(e), type="text")], isError=True
+        )
+
+
+@app.tool(
+    name="impossible",
+    description="Declare the current task impossible. This will end the current task.",
+)
+def impossible_task(reason: str, ctx: Context) -> CallToolResult:
+    """Declare the current task impossible. This will end the current task."""
+    try:
+        environment = ctx.request_context.lifespan_context.env
+        use_images = ctx.request_context.lifespan_context.use_images
+        stop_action = StopAction(reason=reason)
+        obs, terminated = environment.step(stop_action)
+
+        # Generate the ith appropriate success/termination messages
+        # For impossible action, it's successful if the task was truly impossible
+        result = observation_to_tool_result(
+            obs,
+            terminated=terminated,
+            success=environment.success,
+            use_images=use_images,
+        )
+        add_action_to_history(stop_action, result, ctx)
+        logger.info(f"Step {environment.current_step}: {obs['text']}")
+
+        # Save result if the task is terminated
+        save_result_if_terminated(environment, terminated, ctx)
+
+        return result
+    except Exception as e:
+        return CallToolResult(
+            content=[TextContent(text=str(e), type="text")], isError=True
+        )
+
+
+@app.tool(
+    name="start_plancraft_task",
+    description="Start a new Plancraft environment (default use_images=False)",
+)
+def start_plancraft(use_images: bool, ctx: Context) -> CallToolResult:
+    """Tool that uses initialized resources"""
+    # Check if there's an existing environment and if it wasn't terminated yet
+    current_env = ctx.request_context.lifespan_context.env
+    if current_env and not current_env.stopped:
+        # Save the current environment state in results before discarding
+        logger.info("Discarding existing incomplete task")
+        # Reset history when starting a new task
+        ctx.request_context.lifespan_context.history = []
+
+    ctx.request_context.lifespan_context.use_images = use_images
+
+    random_idx = random.randint(
+        0, len(ctx.request_context.lifespan_context.examples) - 1
+    )
+    example: PlancraftExample = ctx.request_context.lifespan_context.examples[
+        random_idx
+    ]
+    # initialize the environment
+    env = PlancraftMCPWrapper(
+        example=example,
+        max_steps=ctx.request_context.lifespan_context.max_steps,
+        resolution=ctx.request_context.lifespan_context.resolution,
+        use_text_inventory=ctx.request_context.lifespan_context.use_text_inventory,
+    )
+    logger.info(f"Environment initialized with example {example.id}")
+    ctx.request_context.lifespan_context.env = env
+
+    obs, _ = env.step()
+    logger.info(f"Step {env.current_step}: {obs['text']}")
+
+    result = observation_to_tool_result(obs, add_instructions=True)
+    return result
+
+
+if __name__ == "__main__":
+    app.run()

{plancraft-0.4.2.dist-info → plancraft-0.4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plancraft
-Version: 0.4.2
+Version: 0.4.4
 Summary: Plancraft: an evaluation dataset for planning with LLM agents
 License: MIT License
         

{plancraft-0.4.2.dist-info → plancraft-0.4.4.dist-info}/RECORD

@@ -2,26 +2,25 @@ plancraft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 plancraft/config.py,sha256=oyn8I_k0Slh-Nyg2javomFertZ5ZHiY_ndAVqfJYQvQ,4010
 plancraft/evaluator.py,sha256=UQujiltf88rCnbNwoglM5tJe5gW9XASew-jLaEbtJZo,15525
 plancraft/generate_dataset.py,sha256=DlrU-PmvWqSNJD1g1-8Lpb8n3N-Ogw3rje1nrRzjGKs,2382
+plancraft/mcp.py,sha256=0DHYAtdgl-CD_oqKpWnTF7L1RdegPK1wU8Naq6dtVIU,15165
 plancraft/simple.py,sha256=7D_SVT2sbXLnHA98P2E_nxV5VPBKbNpij4hB2ArURxA,7329
+plancraft/simple_evaluator.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 plancraft/utils.py,sha256=hCE1oQ-77Me39Vo-sCL7iZPdO-WWYZnBjP41lZWRi20,6339
-plancraft/data/test.curriculum.json,sha256=_mqIqwcmRCcgVA5fOKK27-y3sJdsW86nEqa6ATdyTeA,875349
 plancraft/data/test.json,sha256=4jWfYMAVuZCFmGB4iZJAjlh9_8jXECdaGp8xn7_tAM4,1317131
 plancraft/data/test.small.easy.json,sha256=5NZEJ2PqIgmHQecJOIVQyM1D6GFKyJq7GVmgRudaqQk,189304
 plancraft/data/test.small.json,sha256=eULAG1rdolRMXPrecV-7YoDIheKGyIT5MVpWdISV0wg,270089
-plancraft/data/train.curriculum.json,sha256=eOfGusDtGG1BBvTJdzjUdhTHVAfFro_vGyYgKzZuxvE,1787758
 plancraft/data/train.json,sha256=asZIFnkBdgupPKRXacM4J0Ngt21B2BrMT6oPgFA96HI,2697710
-plancraft/data/val.curriculum.json,sha256=fso4S2g0kqMk7Ehz6ObQmJHk4wq0gAD2YQm0R8Nb95E,866889
 plancraft/data/val.json,sha256=IToAiaqUNQi_xhX1bzmInuskLaT7C2ryQjP-CZkzL24,1304403
 plancraft/data/val.small.easy.json,sha256=9zEmqepjXG2NIp88xnFqOCkwsUsku3HEwHoQGxgTr6U,190252
 plancraft/data/val.small.json,sha256=76E9EFaljDQyAokg97e-IblvcOe6KbrdKkXvRxhhkgo,237653
 plancraft/environment/__init__.py,sha256=XFsFny4lH195AwAmL-WeCaF9ZCMgc7IgXIwhQ8FTdgE,505
 plancraft/environment/actions.py,sha256=Pub21caxM5iZ9IaX-ny1-xxr_peJIwwV_QAx3BVSry0,11551
-plancraft/environment/env.py,sha256=A4532st7JFBYBF_Nh0CEEi3ZTLJAeaB3t9PAIVSemj0,16390
+plancraft/environment/env.py,sha256=B7VpIMcQKITyDmkHgBoR4KbmxmM1b4A6Y-1_b90EMXo,16428
 plancraft/environment/items.py,sha256=Z9rhSyVDEoHF1pxRvhyiT94tyQJaWHi3wUHVcamz82o,221
-plancraft/environment/planner.py,sha256=uIOJjIoyT_4pxeWeTKb8BkLJyKZG0-AMoEOkZs6Ua9A,19340
+plancraft/environment/planner.py,sha256=-ZN6MSQxMTNfexa6ixzzFKK-qBSB4jbxOJLtknnHju8,20437
 plancraft/environment/prompts.py,sha256=NU9YHAz3id-IgaukQvEi5uLlpEstpE5_Hccvvq1At2Y,6950
 plancraft/environment/recipes.py,sha256=0vwzOU86eZmGN2EpZVSIvzxpx0AOBWNPxTtAOFBN2A0,19570
-plancraft/environment/sampler.py,sha256=F9_lI6cyg79HkeSLJVyvh9yZkT-B9PlJWyqaoAfAhwY,7502
+plancraft/environment/sampler.py,sha256=BworSMWQ-TLbV9068tkNOdo4ZLP-UDox6Laeb4Weu9k,7723
 plancraft/environment/search.py,sha256=z31eEwQBY7WJaYVBEEwulFS8P3h1Nwo1Th9BaCTxk5M,2085
 plancraft/environment/assets/constants.json,sha256=kyOIOh82CTTMMGEIS60k5k6M-6fkEmYDoGAnvi3Zx5k,1379016
 plancraft/environment/assets/minecraft_font.ttf,sha256=AzoK9cgggXwjFPHtIO7uz-YaDrminl3nvB-VsaTvTAk,60992
@@ -1924,7 +1923,7 @@ plancraft/models/generators.py,sha256=7COMLjjx_HbTWJqINNLqqExQv7gLikfLTViacAdSt5
 plancraft/models/oracle.py,sha256=f-0KWlBuHy6wcxmDsxM3MQ_QwfBstzfbA26mlk1MgLA,1657
 plancraft/models/utils.py,sha256=xgkP5jqCeFfkKe3Xd4ZYfTqiEJ-dA-qgFAC-J35ub3E,4029
 plancraft/train/dataset.py,sha256=oFqEd4LG9oEQ-71teh0Wf7-jJbtybT2ZibfM2bBdBkM,5474
-plancraft-0.4.2.dist-info/METADATA,sha256=OMyTZhI_6V_7geLfA1i7g3sJTB9dh6LKZB76Ys3aqLY,12391
-plancraft-0.4.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-plancraft-0.4.2.dist-info/licenses/LICENSE,sha256=YGR8ehDB4t-T-lOQKMfKNR-2zsOU7E3E5NA8t25HKE0,1070
-plancraft-0.4.2.dist-info/RECORD,,
+plancraft-0.4.4.dist-info/METADATA,sha256=Yjro1BL1G5QoDlC8v_RStAtPZykvO5pDOwdaHV_8U-c,12391
+plancraft-0.4.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+plancraft-0.4.4.dist-info/licenses/LICENSE,sha256=YGR8ehDB4t-T-lOQKMfKNR-2zsOU7E3E5NA8t25HKE0,1070
+plancraft-0.4.4.dist-info/RECORD,,