code: def create_move_line(
      maze_repr: str, moves: List[str], first_move_only: bool
  ) -> Dict[str, Union[List[Dict[str, str]], str]]:
      """
      Creates a JSON-line formatted line for a maze example.
  
      Args:
          maze_repr (str): String representation of the maze.
          moves (List[str]): List of moves in the shortest path.
          first_move_only (bool): Whether to return only the first move or all moves.
  
      Returns:
          Dict[str, Union[List[Dict[str, str]], str]]: A dictionary containing the move line.
      """
      task_description = f"""**Task Description:**
  <task_description>
  You will be given a text-based 2D maze represented by numbers. The maze consists of pathways (0), walls (1), a starting point (2), and an exit (3).
  Your task is to determine the {'correct first move'if first_move_only else'full solution (series of moves) to solve the maze'}, based on the following rules:
  - You can move up, down, left, or right to the immediate next cell in the chosen direction. The directions are always 
  considered from a top-down view of the maze: regardless of your previous move 'up' moves to the cell above (True North), 
  'down' to the cell below, 'left' to the cell on the left, and 'right' to the cell on the right.
  - Moves that lead to a wall (1) or outside the maze boundaries are not allowed.
  - The goal is to reach the exit (3) from the starting point (2) using the shortest possible legal path.
  - When considering potential moves, exclude directions that lead out of the maze boundaries or back to a previously visited location.
  </task_description-end>
  **Instructions:**
  <instructions>
  1. Write down the maze in its current form.
  2. Make some initial inferences based on the layout of the maze, the location of the starting point (2), the exit (3), and the walls (1).
  3. Identify possible moves from the start position (2) [up, down, left, right], eliminate those that lead to walls or outside the maze. Print the remaining options.
  4. Work through a logical chain of thought to propose a solution to the maze. This should involve identifying the 
  possible moves from the current position and eliminating those that lead to walls or outside the maze.
  5. Critically evaluate your solution, identify any flaws in your decision-making, and adjust the solution if needed.
  {''if first_move_only else'6. Repeat steps 1 and 5 until you reach the exit (3).'} 
  <instructions-end>
  
  <example>
  For example, you may be given the following maze:
  <maze>
  [0,1,0]\n[0,1,0]\n[0,2,3] 
  <maze-end>
  
  <solution-formating>
  The final answer should be in exactly this format:
  {'Solution: [up] **GIVE ONLY THE FIRST STEP** do not inlucde more then one item inside the brackets' if first_move_only else 'Solution: [up,up,left]'}
  <solution-formating-end>
  
  <example-response>
  **Expected Response:**
  1) reprint the maze as it is given to us: [0,1,0]\n[0,1,0]\n[0,2,3] 
  2) the exit appears to be directly to the right of the start position,
  3) the possible moves from the start position are: [right, left] because down goes out of bounds, and up runs into a wall.
  4) the solution is: [right] because left moves away from the exit (3) and right directly leads to the exit.
  5) the solution is correct, no flaws in decision making.
  Solution: [right]
  <example-response-end>
  
  <example-end>
  
  Here is your maze. Please solve it:
  <maze-to-solve>
  {maze_repr}
  <maze-to-solve-end>
  
  Your Notes and thoughts:
  Your Solution:
  """
  
      return {
          "input": [
              {"role": "user", "content": task_description},
          ],
          "ideal": (f"[{moves[0]}]" if first_move_only else f"{moves}")
          if moves
          else "No valid path",
      }
  
file_path: evals/evals/registry/data/mazes/nxn_maze_eval_generator.py
imports: import concurrent.futures
  import json
  import os
  import random
  import threading
  from typing import Dict, List, Tuple, Union
  import networkx
  import numpy
  from numpy import ndarray
  from tqdm import tqdm
label_desc: Use image node_id 7 for calling a global function with example usage: create_move_line(maze_repr, moves, first_move_only) and returns: dict