Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'chair', 'walllamp', 'ceilingfan', 'drawing', 'knifeblock', 'floor', 'ceiling', 'keyboard', 'remote_control', 'purse', 'ceilinglamp', 'tvstand', 'balanceball', 'window', 'couch', 'wall', 'oven', 'mouthwash', 'television', 'wine', 'curtain', 'after_shave', 'towel_rack', 'maindoor', 'clothes_scarf', 'hairdryer', 'table', 'light', 'dishwasher']
Task:Watch TV
response:
{
    "thoughts": SIT ON THE COUCH, TURN TV ON WITH REMOTE, FIND A SHOW,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[PUTOBJBACK] <remote_control>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['band-aids', 'ceilingfan', 'milk', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'character', 'folder', 'remote_control', 'button', 'piano_bench', 'ceilinglamp', 'tvstand', 'balanceball', 'faucet', 'window', 'foundation', 'mat', 'couch', 'dustpan', 'wall', 'nightstand', 'powersocket', 'coffee_table', 'television', 'tray', 'curtain', 'table', 'laser_pointer']
Task:Change TV channel
response:

Go to the living room, find the remote control on the coffee table, and change the TV channel.

[WALK] <home_office>
[WALK] <coffee_table>
[FIND] <coffee_table>
[WALK] <coffee_table>
[TURNTO] <coffee_table>
[LOOKAT] <coffee_table>
[FIND] <remote_control>
[TOUCH] <remote_control>
[GRAB] <remote_control>
[FIND] <television>
[TURNTO] <television>
[POINTAT] <television>
[FIND] <button>
[TOUCH] <button>
[PUSH] <button>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['freezer', 'drawing', 'orchid', 'knifeblock', 'hanger', 'floor', 'ceiling', 'dvd_player', 'stamp', 'bedroom', 'desk', 'keyboard', 'toaster', 'faucet', 'shower', 'couch', 'pillow', 'wall', 'oven', 'photoframe', 'bed', 'toothbrush_holder', 'doorjamb', 'towel_rack', 'door', 'bathtub', 'home_office', 'table', 'light', 'dishwasher']
Task:Listen to music
response:
{
    "thoughts": walk to living room, look at the DVD player, switch on the dvd player, look at the sofa, sit on the sofa and listen the music,
    "actions": ['[WALK] <home_office>', '[WALK] <dvd_player>', '[FIND] <dvd_player>', '[TURNTO] <dvd_player>', '[LOOKAT] <dvd_player>', '[SWITCHON] <dvd_player>', '[FIND] <couch>', '[TURNTO] <couch>', '[LOOKAT] <couch>', '[SIT] <couch>']
}

Input:
Scene_Objects:['glue', 'walllamp', 'ceilingfan', 'drawing', 'hanger', 'floor', 'bedroom', 'computer', 'ceilinglamp', 'deck_of_cards', 'iron', 'window', 'electric_shaver', 'couch', 'food_orange', 'wall', 'wall_clock', 'bed', 'novel', 'check', 'television', 'toothbrush_holder', 'wooden_spoon', 'after_shave', 'towel_rack', 'dresser', 'conditioner', 'maindoor', 'table', 'vase']
Task:Relax on sofa
response:

Walk to the living room. Find the sofa. Walk to the sofa. Lie in the sofa.

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[WALK] <couch>
[LIE] <couch>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['fork', 'pot', 'filing_cabinet', 'microwave', 'chair', 'jelly', 'bathroom', 'detergent', 'knife', 'floor', 'toaster', 'mat', 'plate', 'shower', 'faucet', 'dish_soap', 'bowl', 'wall', 'cup', 'coffe_maker', 'food_food', 'after_shave', 'kitchen_counter', 'cupboard', 'hair', 'sink', 'spoon', 'home_office', 'table', 'dishwasher']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": I walk to the kitchen and find the dishwasher. I open it. I find the sink and grab the dirty plates, cups, bowls, and utensils. I rinse off the dirty dishes under the faucet. I then place the dirty dishes into the dishwasher. I add soap to the dishwasher and close the lid. I turn it on and wait.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <sink>', '[FIND] <bowl>', '[GRAB] <bowl>', '[RINSE] <bowl>', '[PUTBACK] <bowl> <dishwasher>', '[FIND] <cup>', '[GRAB] <cup>', '[RINSE] <cup>', '[PUTBACK] <cup> <dishwasher>', '[FIND] <fork>', '[GRAB] <fork>', '[RINSE] <fork>', '[PUTBACK] <fork> <dishwasher>', '[FIND] <knife>', '[GRAB] <knife>', '[RINSE] <knife>', '[PUTBACK] <knife> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[RINSE] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <spoon>', '[GRAB] <spoon>', '[RINSE] <spoon>', '[PUTBACK] <spoon> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[TURNTO] <dishwasher>']
}

Input:
Scene_Objects:['juice', 'toilet', 'chair', 'detergent', 'bathroom_counter', 'ceiling', 'character', 'desk', 'laptop', 'tvstand', 'faucet', 'electric_shaver', 'mousepad', 'couch', 'food_orange', 'bench', 'powersocket', 'cup', 'bed', 'novel', 'razor', 'oven_mitts', 'curtain', 'after_shave', 'cd', 'headset', 'dresser', 'pajamas', 'bathroom_cabinet', 'tooth_paste']
Task:Pick up phone
response:

I'll enter the location containing the phone. Once there, I'll locate the phone, and move close to it. I'll then use my hand to pick up the phone such that I can then use it.

[WALK] <home_office>
[WALK] <phone>
[FIND] <phone>
[WALK] <phone>
[TURNTO] <phone>
[LOOKAT] <phone>
[GRAB] <phone>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'pot', 'glue', 'tablelamp', 'microwave', 'walllamp', 'knife', 'knifeblock', 'longboard', 'floor', 'phone', 'computer', 'toaster', 'plate', 'shoe-shine_kit', 'dish_soap', 'mousepad', 'food_orange', 'wall', 'nightstand', 'oven', 'toy', 'newspaper', 'coffe_maker', 'tray', 'vacuum_cleaner', 'dresser', 'hairdryer', 'dishwasher', 'vase']
Task:Wash dishes with dishwasher
response:
{
    "thoughts": Walk to the  kitchen. Open the dishwasher. Put plates into the dishwasher. Put dish soap into the dishwasher. Close the dishwasher. Turn on the dishwasher.,
    "actions": ['[WALK] <dining_room>', '[WALK] <dishwasher>', '[FIND] <dishwasher>', '[OPEN] <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <plate>', '[GRAB] <plate>', '[PUTBACK] <plate> <dishwasher>', '[FIND] <dish_soap>', '[GRAB] <dish_soap>', '[PUTBACK] <dish_soap> <dishwasher>', '[CLOSE] <dishwasher>', '[SWITCHON] <dishwasher>']
}

Input:
Scene_Objects:['dry_pasta', 'spectacles', 'food_pizza', 'tablelamp', 'blender', 'microwave', 'chair', 'cat', 'trashcan', 'dough', 'orchid', 'knifeblock', 'clothes_underwear', 'desk', 'food_bacon', 'shoe-shine_kit', 'balanceball', 'deck_of_cards', 'couch', 'towel', 'nightstand', 'oven', 'newspaper', 'keys', 'pencil', 'laundry_detergent', 'maindoor', 'bag', 'laser_pointer', 'shoe_rack']
Task:Drink
response:

[WALK] <dining_room>
[WALK] <water_glass>
[FIND] <water_glass>
[GRAB] <water_glass>
[DRINK] <water_glass>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'food_ice_cream', 'food_carrot', 'longboard', 'ceiling', 'stamp', 'food_cake', 'stovefan', 'mat', 'oil', 'food_peanut_butter', 'dining_room', 'broom', 'pasta', 'basket_for_clothes', 'bed', 'coffe_maker', 'television', 'razor', 'tray', 'after_shave', 'mouse', 'laundry_detergent', 'clothes_scarf', 'sink', 'bathroom_cabinet', 'dishwasher', 'laser_pointer', 'clothes_shirt', 'washing_machine']
Task:Wash clothes
response:
{
    "thoughts": Go to kitchen, find washing machine, find laundry, put laundry in washing machine, find soap, put soap in washing machine, turn on.,
    "actions": ['[WALK] <dining_room>', '[WALK] <washing_machine>', '[FIND] <washing_machine>', '[FIND] <basket_for_clothes>', '[GRAB] <basket_for_clothes>', '[OPEN] <washing_machine>', '[PUTBACK] <basket_for_clothes> <washing_machine>', '[WALK] <laundry_detergent>', '[FIND] <laundry_detergent>', '[GRAB] <laundry_detergent>', '[POUR] <laundry_detergent> <washing_machine>', '[CLOSE] <washing_machine>', '[SWITCHON] <washing_machine>']
}

Input:
Scene_Objects:['pot', 'food_pizza', 'tablelamp', 'walllamp', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'shampoo', 'bedroom', 'mop_bucket', 'faucet', 'balanceball', 'towel', 'wall', 'photoframe', 'keys', 'novel', 'razor', 'television', 'diary', 'kettle', 'coffee_pot', 'cd', 'sink', 'bathroom_cabinet', 'home_office', 'soap', 'hands_both', 'shoe_rack']
Task:Wash hands
response:

I go to the bathroom and locate the sink. I turn the faucet so that water is running, and rinse my hands briefly. Then I grab the soap and squeeze some onto my hands. I spend a few minutes rubbing my hands together, then I rinse them again. Finally, I turn the faucet off and wipe my hands on a towel.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <sink>
[TURNTO] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <hands_both>
[RINSE] <hands_both>
[FIND] <soap>
[GRAB] <soap>
[SQUEEZE] <soap>
[WASH] <hands_both>
[RINSE] <hands_both>
[SWITCHOFF] <faucet>
[FIND] <towel>
[GRAB] <towel>
[WIPE] <hands_both>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sheets', 'water_glass', 'food_salt', 'freezer', 'walllamp', 'blow_dryer', 'detergent', 'drawing', 'wallshelf', 'floor', 'ceiling', 'phone', 'desk', 'stovefan', 'mat', 'iron', 'oil', 'closetdrawer', 'couch', 'pillow', 'wall', 'newspaper', 'keys', 'food_food', 'television', 'kitchen_counter', 'cupboard', 'door', 'bathroom_cabinet', 'tooth_paste']
Task:Drink
response:
{
    "thoughts": walk to kitchen ,find fridge ,open fridge ,find water  glass , drink from water glass,
    "actions": ['[WALK] <dining_room>', '[WALK] <freezer>', '[FIND] <freezer>', '[OPEN] <freezer>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['tablelamp', 'walllamp', 'drawing', 'knife', 'floor', 'ceiling', 'bookshelf', 'ceilinglamp', 'shower', 'food_noodles', 'oil', 'dining_room', 'wall', 'oven', 'photoframe', 'newspaper', 'check', 'coffe_maker', 'television', 'wooden_spoon', 'doorjamb', 'cards', 'pencil', 'shoes', 'cupboard', 'controller', 'door', 'maindoor', 'light', 'teeth']
Task:Turn on light
response:


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['walllamp', 'trashcan', 'phone', 'ceiling', 'character', 'desk', 'bookmark', 'toaster', 'stovefan', 'shoe-shine_kit', 'shower', 'window', 'wall', 'pasta', 'oven', 'powersocket', 'clothes_gloves', 'novel', 'coffe_maker', 'check', 'coin', 'curtain', 'doorjamb', 'cards', 'towel_rack', 'kitchen_counter', 'chessboard', 'napkin', 'bathroom_cabinet', 'light']
Task:Turn on light
response:
{
    "thoughts": walk to living room ,find electrical outlet , switch on eletrical outlet,
    "actions": ['[WALK] <home_office>', '[WALK] <electrical_outlet>', '[FIND] <electrical_outlet>', '[SWITCHON] <electrical_outlet>']
}

Input:
Scene_Objects:['freezer', 'ceilingfan', 'drawing', 'floor', 'ceiling', 'stamp', 'remote_control', 'computer', 'clothes_jacket', 'ceilinglamp', 'tvstand', 'balanceball', 'iron', 'window', 'shoe-shine_kit', 'shower', 'mousepad', 'deck_of_cards', 'couch', 'food_kiwi', 'wall', 'cup', 'television', 'ice', 'curtain', 'conditioner', 'door', 'table', 'vase', 'tooth_paste']
Task:Watch TV
response:

walk to living room ,find television , switch on remote control

[WALK] <home_office>
[WALK] <television>
[FIND] <television>
[FIND] <remote_control>
[SWITCHON] <remote_control>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['jelly', 'freezer', 'walllamp', 'bathroom', 'bills', 'needle', 'drawing', 'character', 'table_cloth', 'toaster', 'picture', 'floor_lamp', 'window', 'mousepad', 'microphone', 'food_kiwi', 'wall', 'wall_clock', 'newspaper', 'bed', 'television', 'tray', 'cupboard', 'controller', 'door', 'sink', 'bathtub', 'bathroom_cabinet', 'light', 'home_office']
Task:Turn on light
response:
{
    "thoughts": I go to bedroom and locate a lamp. This lamp can be turned on by touch, as it has capacitive sensing. So I do it.,
    "actions": ['[WALK] <bedroom>', '[WALK] <floor_lamp>', '[FIND] <floor_lamp>', '[TOUCH] <floor_lamp>', '[SWITCHON] <floor_lamp>']
}

Input:
Scene_Objects:['fork', 'walllamp', 'detergent', 'orchid', 'knife', 'hanger', 'floor', 'shampoo', 'dvd_player', 'character', 'keyboard', 'mop_bucket', 'toaster', 'dining_room', 'wall', 'oven', 'cutting_board', 'light_bulb', 'coffe_maker', 'food_food', 'razor', 'tray', 'wooden_spoon', 'pencil', 'dishrack', 'cupboard', 'bathroom_cabinet', 'dishwasher', 'colander', 'laser_pointer']
Task:Wash dishes by hand
response:

walk to kitchen , find dish washer , wash the dishe rack , put dishes in dish washer , switch on dish washer

[WALK] <dining_room>
[WALK] <dishwasher>
[FIND] <dishwasher>
[FIND] <dishrack>
[FIND] <dishrack>
[GRAB] <dishrack>
[FIND] <dishwasher>
[OPEN] <dishwasher>
[PUTBACK] <dishrack> <dishwasher>
[SWITCHON] <dishwasher>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'cat', 'food_carrot', 'drawing', 'knifeblock', 'cpuscreen', 'wallshelf', 'hanger', 'bathroom_counter', 'ceiling', 'desk', 'bookshelf', 'keyboard', 'mousepad', 'bench', 'newspaper', 'coffe_maker', 'food_food', 'tray', 'curtain', 'mouse', 'door', 'hairdryer', 'sink', 'food_steak', 'light', 'dishwasher', 'spoon', 'table', 'board_game']
Task:Write  school paper
response:
{
    "thoughts": Writing  and drafting a paper for  class work,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[SWITCHOFF] <computer>']
}

Input:
Scene_Objects:['sponge', 'pot', 'juice', 'cd_player', 'toilet', 'freezer', 'trashcan', 'bedroom', 'remote_control', 'button', 'clothes_jacket', 'toaster', 'laptop', 'ceilinglamp', 'plate', 'homework', 'dining_room', 'broom', 'bench', 'tape', 'keys', 'coffe_maker', 'television', 'towel_rack', 'hair', 'cupboard', 'maindoor', 'sink', 'clothes_skirt', 'vase']
Task:Listen to music
response:

I walk to my living room. Find CD player. Plugin the CD player to Power. Also find the remote control. Push the Botton

[WALK] <home_office>
[WALK] <cd_player>
[FIND] <cd_player>
[PLUGIN] <cd_player>
[FIND] <remote_control>
[GRAB] <remote_control>
[FIND] <button>
[PUSH] <button>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'pot', 'tablelamp', 'chair', 'walllamp', 'drawing', 'cpuscreen', 'wallshelf', 'floor', 'phone', 'desk', 'keyboard', 'computer', 'mat', 'deck_of_cards', 'picture', 'mousepad', 'wall', 'oven', 'powersocket', 'check', 'television', 'tray', 'doorjamb', 'towel_rack', 'cards', 'mouse', 'door', 'light', 'printing_paper']
Task:Add paper to printer
response:
{
    "thoughts": Take a stack of paper, about 25 pieces. Place carefully in the paper tray.,
    "actions": ['[WALK] <home_office>', '[WALK] <desk>', '[FIND] <printing_paper>', '[GRAB] <printing_paper>', '[WALK] <fax_machine>', '[PUTBACK] <printing_paper> <fax_machine>']
}

Input:
Scene_Objects:['nail_polish', 'orchid', 'drawing', 'bathroom_counter', 'floor', 'ceiling', 'thread', 'faucet', 'couch', 'dining_room', 'wall', 'nightstand', 'bench', 'wall_clock', 'photoframe', 'coffe_maker', 'food_food', 'lighter', 'doorjamb', 'towel_rack', 'diary', 'shoes', 'comb', 'door', 'sink', 'bathroom_cabinet', 'table', 'soap', 'dirt', 'hands_both']
Task:Wash hands
response:

Go to the bathroom. turn on the water in the sink. apply soap to hands. rub hands together. rinse hands with water. turn off the water.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <sink>
[FIND] <soap>
[GRAB] <soap>
[FIND] <hands_both>
[SCRUB] <hands_both>
[RINSE] <hands_both>
[WIPE] <hands_both>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['sponge', 'tablelamp', 'chair', 'walllamp', 'orchid', 'knifeblock', 'wallshelf', 'floor', 'ceiling', 'remote_control', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'window', 'closetdrawer', 'couch', 'pillow', 'wall', 'nightstand', 'tape', 'photoframe', 'coffee_table', 'television', 'toothbrush_holder', 'razor', 'curtain', 'dresser', 'pajamas', 'table']
Task:Watch TV
response:
{
    "thoughts": I walk into the living room and sit on the couch. I pick up the remote to turn on the television. I put down the remote on the coffee table and look at the television.,
    "actions": ['[WALK] <home_office>', '[WALK] <couch>', '[FIND] <couch>', '[SIT] <couch>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[FIND] <coffee_table>', '[PUTBACK] <remote_control> <coffee_table>', '[TURNTO] <television>', '[LOOKAT] <television>']
}

Input:
Scene_Objects:['glue', 'filing_cabinet', 'tablelamp', 'microwave', 'toilet', 'dog', 'walllamp', 'bathroom', 'knifeblock', 'food_egg', 'food_bacon', 'brush', 'mat', 'deck_of_cards', 'balanceball', 'tvstand', 'ceilinglamp', 'picture', 'couch', 'wall', 'tape', 'cup', 'toilet_paper', 'food_food', 'video_game_controller', 'water', 'cupboard', 'bathroom_cabinet', 'table', 'vase']
Task:Drink
response:

I go to the kitchen. I get a glass. I fill it with water. I take a drink from the glass.

[WALK] <dining_room>
[WALK] <cup>
[FIND] <cup>
[GRAB] <cup>
[WALK] <water>
[FIND] <water>
[GRAB] <water>
[POUR] <water> <cup>
[DRINK] <cup>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['filing_cabinet', 'toilet', 'chair', 'walllamp', 'trashcan', 'cpuscreen', 'floor', 'ceiling', 'character', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'faucet', 'shower', 'mousepad', 'couch', 'pillow', 'dining_room', 'wall', 'powersocket', 'coffe_maker', 'television', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'table', 'coffee']
Task:Call family member with skype application
response:
{
    "thoughts": Sit down on desk chair located in front of computer.  Turn on computer.  Log in to skype application.  Locate individual to call on contacts list.  Press the call button with computer mouse.,
    "actions": ['[WALK] <home_office>', '[WALK] <chair>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <computer>', '[SWITCHON] <computer>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[FIND] <mouse>', '[GRAB] <mouse>', '[TURNTO] <computer>', '[POINTAT] <computer>']
}

Input:
Scene_Objects:['sponge', 'filing_cabinet', 'tea', 'microwave', 'toilet', 'chair', 'freezer', 'walllamp', 'detergent', 'trashcan', 'toothbrush', 'orchid', 'needle', 'shampoo', 'tea_bag', 'alcohol', 'mat', 'shower', 'mousepad', 'towel', 'wall', 'cup', 'bed', 'light_bulb', 'coffe_maker', 'wooden_spoon', 'shoes', 'home_office', 'vase', 'soap']
Task:Pick up phone
response:

Walk into the living room, walk over to phone, grab the phone, put it to your ear .

[WALK] <home_office>
[WALK] <phone>
[GRAB] <phone>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tea', 'cat', 'drawing', 'bills', 'bathroom_counter', 'floor', 'ceiling', 'character', 'bedroom', 'mail', 'alcohol', 'mat', 'faucet', 'clothes_pants', 'pillow', 'wall', 'wall_clock', 'oven', 'pasta', 'bench', 'coffee_filter', 'ice', 'paper_towel', 'conditioner', 'sink', 'bathroom_cabinet', 'clothes_skirt', 'soap', 'hands_both', 'shoe_rack']
Task:Wash hands
response:
{
    "thoughts": I walk to the bathroom and find the sink. I grab the soap and rub some on my hands. I turn the faucet on and put my hands in the water. I rinse my hands and then turn off the faucet. Then I dry my hands on a paper towel.,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[RINSE] <hands_both>', '[FIND] <paper_towel>', '[GRAB] <paper_towel>', '[WIPE] <hands_both>']
}

Input:
Scene_Objects:['filing_cabinet', 'shoe_rack', 'food_salt', 'mop', 'microwave', 'dog', 'jelly', 'walllamp', 'drawing', 'needle', 'food_egg', 'desk', 'stamp', 'computer', 'ceilinglamp', 'window', 'mousepad', 'food_orange', 'pillow', 'bench', 'cup', 'oven_mitts', 'wooden_spoon', 'pencil', 'dresser', 'maindoor', 'bag', 'table', 'instrument_violin', 'creditcard']
Task:Listen to music
response:


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'beer', 'crayon', 'chair', 'freezer', 'walllamp', 'orchid', 'drawing', 'hanger', 'floor', 'ceiling', 'bedroom', 'bookshelf', 'food_cake', 'ceilinglamp', 'tvstand', 'mat', 'couch', 'food_peanut_butter', 'pillow', 'wall', 'nightstand', 'powersocket', 'cup', 'food_food', 'television', 'curtain', 'pencil', 'kitchen_counter', 'door']
Task:Relax on sofa
response:
{
    "thoughts": I walk to the sofa, and lie down on the sofa.,
    "actions": ['[WALK] <couch>', '[LIE] <couch>']
}

Input:
Scene_Objects:['detergent', 'trashcan', 'drawing', 'clothes_underwear', 'bathroom_counter', 'floor', 'ceiling', 'longboard', 'bookshelf', 'toaster', 'ceilinglamp', 'deck_of_cards', 'faucet', 'balanceball', 'shower', 'mousepad', 'wall', 'nightstand', 'photoframe', 'light_bulb', 'novel', 'food_food', 'water', 'kitchen_counter', 'sink', 'bag', 'bathroom_cabinet', 'napkin', 'soap', 'hands_both']
Task:Wash hands
response:

I turn on faucet. I hold out my hands. I get my hands wet.

[WALK] <bathroom>
[WALK] <faucet>
[FIND] <faucet>
[TURNTO] <faucet>
[FIND] <water>
[GRAB] <water>
[FIND] <hands_both>
[POUR] <water> <hands_both>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'chair', 'freezer', 'walllamp', 'trashcan', 'knifeblock', 'needle', 'cpuscreen', 'floor', 'character', 'keyboard', 'table_cloth', 'plate', 'faucet', 'window', 'oil', 'mousepad', 'pillow', 'wall', 'oven', 'food_cheese', 'bed', 'tray', 'kettle', 'kitchen_counter', 'dresser', 'cupboard', 'sink', 'home_office', 'light']
Task:Wash dishes by hand
response:
{
    "thoughts": Walking towards sink and look at the leftover plates. Scrape dishes to remove leftover food - use a rubber spatula or paper towel. Fill sink or dishpan with clean, hot water. Then wash and rinse to removing residues. Finally leave it to dry.,
    "actions": ['[WALK] <dining_room>', '[WALK] <kitchen_counter>', '[FIND] <plate>', '[TURNTO] <plate>', '[LOOKAT] <plate>', '[GRAB] <plate>', '[SCRUB] <plate>', '[RINSE] <plate>', '[WASH] <plate>', '[PUTBACK] <plate> <kitchen_counter>']
}

Input:
Scene_Objects:['dry_pasta', 'bathroom', 'ceilingfan', 'knife', 'drawing', 'needle', 'knifeblock', 'bathroom_counter', 'shampoo', 'floor', 'ceiling', 'phone', 'piano_bench', 'faucet', 'window', 'teeth', 'clothes_pants', 'wall', 'photoframe', 'check', 'oven_mitts', 'tray', 'pencil', 'clothes_dress', 'sink', 'bathroom_cabinet', 'home_office', 'clothes_skirt', 'soap', 'hands_both']
Task:Wash hands
response:

Go to the bathroom and to the sink, turn the faucet on, push the bottle of soap onto your hands and scrub them. Then rinse your hands out and turn the faucet off.

[WALK] <bathroom>
[WALK] <sink>
[FIND] <sink>
[FIND] <faucet>
[SWITCHON] <faucet>
[FIND] <soap>
[PUSH] <soap>
[FIND] <hands_both>
[SCRUB] <hands_both>
[RINSE] <hands_both>
[SWITCHOFF] <faucet>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['tablelamp', 'chair', 'walllamp', 'blow_dryer', 'orchid', 'drawing', 'cpuscreen', 'wallshelf', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'computer', 'ceilinglamp', 'tvstand', 'mat', 'mousepad', 'couch', 'pillow', 'wall', 'nightstand', 'oven', 'television', 'doorjamb', 'mouse', 'dresser', 'door', 'dishwasher']
Task:Write an email
response:
{
    "thoughts": Turn on PC and log onto email account. Type email and send it. Switch off computer.,
    "actions": ['[WALK] <home_office>', '[WALK] <computer>', '[SWITCHON] <computer>', '[FIND] <keyboard>', '[TYPE] <keyboard>', '[TURNTO] <computer>', '[LOOKAT] <computer>', '[SWITCHOFF] <computer>']
}

Input:
Scene_Objects:['sheets', 'pot', 'ceilingfan', 'drawing', 'cpuscreen', 'phone', 'desk', 'keyboard', 'mail', 'mat', 'window', 'towel', 'dining_room', 'wall', 'pasta', 'oven', 'cup', 'check', 'curtain', 'rag', 'doorjamb', 'cards', 'cupboard', 'conditioner', 'clothes_scarf', 'napkin', 'home_office', 'vase', 'soap', 'laser_pointer']
Task:Listen to music
response:

I go to my bedroom, and then I switch on the radio

[WALK] <bedroom>
[WALK] <stereo>
[FIND] <stereo>
[SWITCHON] <stereo>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['spectacles', 'microwave', 'chair', 'dog', 'walllamp', 'drawing', 'cpuscreen', 'hanger', 'floor', 'ceiling', 'phone', 'desk', 'bookshelf', 'keyboard', 'computer', 'laptop', 'mat', 'mousepad', 'closetdrawer', 'couch', 'wall', 'powersocket', 'coffe_maker', 'wine', 'doorjamb', 'kettle', 'mouse', 'pencil', 'dresser', 'light']
Task:Work
response:
{
    "thoughts": I walk in. Turn on the light. Set in my chair. Turn on lap top. And start to work.,
    "actions": ['[WALK] <home_office>', '[WALK] <light>', '[FIND] <light>', '[SWITCHON] <light>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <laptop>', '[GRAB] <laptop>', '[SWITCHON] <laptop>']
}

Input:
Scene_Objects:['dry_pasta', 'tablelamp', 'crayon', 'band-aids', 'nail_polish', 'cat', 'food_carrot', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'food_bacon', 'ceilinglamp', 'shoe-shine_kit', 'window', 'couch', 'food_kiwi', 'wall', 'bed', 'keys', 'check', 'television', 'oven_mitts', 'curtain', 'conditioner', 'maindoor', 'instrument_guitar', 'table', 'bathroom_cabinet']
Task:Pet cat
response:

The cat is laying on the couch in the living room. I want to pet it, so I am going to walk to the living room, sit on the couch, and pet the cat.

[WALK] <home_office>
[WALK] <couch>
[SIT] <couch>
[FIND] <cat>
[TURNTO] <cat>
[LOOKAT] <cat>
[TOUCH] <cat>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['water_glass', 'pot', 'food_salt', 'mop', 'freezer', 'walllamp', 'detergent', 'knifeblock', 'floor', 'ceiling', 'purse', 'button', 'piano_bench', 'food_bacon', 'stovefan', 'ceilinglamp', 'tvstand', 'faucet', 'form', 'wall', 'bench', 'food_food', 'television', 'water', 'kitchen_counter', 'cupboard', 'food_steak', 'sink', 'maindoor', 'table']
Task:Drink
response:
{
    "thoughts": I need to go to Kitchen.  Get a cup.  Fill cup.  Drink,
    "actions": ['[WALK] <dining_room>', '[WALK] <cupboard>', '[FIND] <cupboard>', '[OPEN] <cupboard>', '[FIND] <water_glass>', '[GRAB] <water_glass>', '[WALK] <freezer>', '[WALK] <water>', '[FIND] <water>', '[GRAB] <water>', '[POUR] <water> <water_glass>', '[DRINK] <water_glass>']
}

Input:
Scene_Objects:['chair', 'food_butter', 'ceilingfan', 'drawing', 'food_egg', 'floor', 'keyboard', 'purse', 'ceilinglamp', 'window', 'couch', 'pillow', 'wall', 'nightstand', 'cup', 'food_food', 'television', 'oven_mitts', 'tray', 'curtain', 'diary', 'mouse', 'vacuum_cleaner', 'dresser', 'door', 'table', 'light', 'board_game', 'clothes_shirt', 'shoe_rack']
Task:Relax on sofa
response:

Go to living room.  Find sofa.  Sit on sofa.

[WALK] <home_office>
[WALK] <couch>
[FIND] <couch>
[SIT] <couch>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'freezer', 'walllamp', 'food_carrot', 'orchid', 'drawing', 'wallshelf', 'bathroom_counter', 'floor', 'character', 'shoe-shine_kit', 'faucet', 'couch', 'form', 'wall', 'bench', 'toy', 'cup', 'coffe_maker', 'television', 'doorjamb', 'towel_rack', 'mouse', 'cupboard', 'door', 'sink', 'bathroom_cabinet', 'home_office', 'soap']
Task:Wash hands
response:
{
    "thoughts": walk to bathroom, find sink, turn on faucet, put soap in hands, wash and rinse hands,,
    "actions": ['[WALK] <bathroom>', '[WALK] <sink>', '[FIND] <sink>', '[FIND] <soap>', '[WASH] <soap>', '[RINSE] <soap>']
}

Input:
Scene_Objects:['pot', 'beer', 'toilet', 'jelly', 'milk', 'drawing', 'orchid', 'hanger', 'bathroom_counter', 'floor', 'ceiling', 'dvd_player', 'faucet', 'balanceball', 'mousepad', 'towel', 'dining_room', 'wall', 'photoframe', 'light_bulb', 'towel_rack', 'dresser', 'cupboard', 'maindoor', 'sink', 'bathroom_cabinet', 'home_office', 'light', 'soap', 'hands_both']
Task:Wash hands
response:

I go to the bathroom, open the faucet rinse the hands, wash the hands with soap and rinse again, then wipe with a towel.

[WALK] <bathroom>
[WALK] <faucet>
[FIND] <faucet>
[TURNTO] <faucet>
[FIND] <hands_both>
[RINSE] <hands_both>
[FIND] <soap>
[GRAB] <soap>
[WASH] <hands_both>
[RINSE] <hands_both>
[TURNTO] <faucet>
[FIND] <towel>
[GRAB] <towel>
[WIPE] <hands_both>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['food_pizza', 'tablelamp', 'food_salt', 'cd_player', 'chair', 'freezer', 'bathroom', 'food_carrot', 'orchid', 'knifeblock', 'floor', 'ceiling', 'phone', 'desk', 'bedroom', 'keyboard', 'remote_control', 'computer', 'window', 'mousepad', 'wall', 'nightstand', 'light_bulb', 'check', 'food_onion', 'curtain', 'mouse', 'door', 'light', 'tooth_paste']
Task:Listen to music
response:
{
    "thoughts": Walk to CD player and turn it on then go and sit in a chair and turn the remote control on and then listen to some music.,
    "actions": ['[WALK] <cd_player>', '[SWITCHON] <cd_player>', '[FIND] <chair>', '[SIT] <chair>', '[FIND] <remote_control>', '[TOUCH] <remote_control>']
}

Input:
Scene_Objects:['glue', 'tablelamp', 'chair', 'walllamp', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'character', 'desk', 'keyboard', 'bookshelf', 'computer', 'ceilinglamp', 'balanceball', 'mousepad', 'pillow', 'wall', 'nightstand', 'bench', 'food_food', 'doorjamb', 'kettle', 'mouse', 'pencil', 'headset', 'light']
Task:Browse internet
response:

go to the office, turn computer on, open an browser or any application to open any website.

[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <computer>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['blender', 'chair', 'walllamp', 'detergent', 'milk', 'drawing', 'wallshelf', 'hanger', 'floor', 'ceiling', 'desk', 'bedroom', 'remote_control', 'computer', 'mat', 'tvstand', 'ceilinglamp', 'faucet', 'shower', 'closetdrawer', 'couch', 'pillow', 'wall', 'photoframe', 'television', 'doorjamb', 'diary', 'kitchen_counter', 'dresser', 'napkin']
Task:Watch TV
response:
{
    "thoughts": Find the remote, turn on the TV, watch.,
    "actions": ['[WALK] <home_office>', '[WALK] <remote_control>', '[FIND] <remote_control>', '[GRAB] <remote_control>', '[FIND] <television>', '[SWITCHON] <television>', '[TURNTO] <television>', '[WATCH] <television>']
}

Input:
Scene_Objects:['tablelamp', 'microwave', 'toilet', 'chair', 'trashcan', 'ceilingfan', 'drawing', 'cpuscreen', 'floor', 'ceiling', 'phone', 'desk', 'keyboard', 'bookshelf', 'computer', 'button', 'mail', 'ceilinglamp', 'deck_of_cards', 'balanceball', 'window', 'mousepad', 'wall', 'nightstand', 'photoframe', 'novel', 'doorjamb', 'mouse', 'light', 'dishwasher']
Task:Write an email
response:

Switch on computer, Use keybord and mouse to open e-mail provider, type requested e-mail, click send, close e-mail provider, turn off computer

[WALK] <home_office>
[WALK] <computer>
[FIND] <computer>
[SWITCHON] <computer>
[FIND] <mouse>
[FIND] <keyboard>
[FIND] <mail>
[OPEN] <mail>
[TYPE] <keyboard>
[FIND] <button>
[PUSH] <button>
[CLOSE] <mail>
[SWITCHOFF] <computer>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['microwave', 'toilet', 'freezer', 'walllamp', 'bathroom', 'trashcan', 'orchid', 'floor', 'toaster', 'mat', 'faucet', 'shower', 'pillow', 'wall', 'nightstand', 'bench', 'toy', 'coffe_maker', 'television', 'curtain', 'after_shave', 'doorjamb', 'towel_rack', 'kitchen_counter', 'chessboard', 'sink', 'home_office', 'bathroom_cabinet', 'table', 'instrument_violin']
Task:Go to toilet
response:
{
    "thoughts": Walk to the bathroom.  Find the toilet.  Lift the top of the toilet.  Sit on the toilet.,
    "actions": ['[WALK] <bathroom>', '[WALK] <toilet>', '[FIND] <toilet>', '[OPEN] <toilet>', '[SIT] <toilet>']
}

Input:
Scene_Objects:['spectacles', 'sheets', 'chair', 'ground_coffee', 'walllamp', 'hanger', 'longboard', 'floor', 'ceiling', 'phone', 'bookshelf', 'keyboard', 'computer', 'stovefan', 'tvstand', 'stereo', 'window', 'clothes_hat', 'wall', 'nightstand', 'bench', 'box', 'food_cheese', 'doorjamb', 'mouse', 'dresser', 'cupboard', 'hair', 'door', 'light']
Task:Turn on light
response:

Walk to living room.  Find light switch.  Switch on light switch.

[WALK] <home_office>
[WALK] <light>
[FIND] <light>
[SWITCHON] <light>


Instruction:
You serve as an AI task planner.
1. Your task is to create a plan to achieve a goal by converting it into a sequence of actions. Each action should follow the format "[verb] <target1> <target2>", where 'verb' represents the action, and 'target1' and 'target2' are optional arguments.
2. You must describe your plan in natural language at the beginning. After that, you should list all the actions together.
Ensure that you response can be parsed by Python json.loads.

Here is an example plan to achieve a goal for reference:
Scene_Objects:['pot', 'freezer', 'ceilingfan', 'drawing', 'knifeblock', 'bathroom_counter', 'floor', 'ceiling', 'phone', 'keyboard', 'bookshelf', 'faucet', 'picture', 'window', 'dustpan', 'towel', 'wall', 'nightstand', 'photoframe', 'keys', 'toothbrush_holder', 'food_donut', 'mouse', 'kitchen_counter', 'sink', 'bathroom_cabinet', 'table', 'vase', 'soap', 'hands_both']
Task:Wash hands
response:
{
    "thoughts": Cleaning hands,
    "actions": ['[WALK] <bathroom>', '[WALK] <faucet>', '[FIND] <faucet>', '[SWITCHON] <faucet>', '[FIND] <soap>', '[GRAB] <soap>', '[FIND] <hands_both>', '[SCRUB] <hands_both>', '[PUTOBJBACK] <soap>', '[RINSE] <hands_both>', '[SWITCHOFF] <faucet>', '[FIND] <towel>', '[GRAB] <towel>', '[WIPE] <hands_both>', '[PUTOBJBACK] <towel>']
}

Input:
Scene_Objects:['sheets', 'pot', 'toilet', 'blow_dryer', 'bathroom', 'trashcan', 'orchid', 'dvd_player', 'keyboard', 'mail', 'computer', 'food_bacon', 'stovefan', 'ceilinglamp', 'picture', 'window', 'couch', 'clothes_pants', 'oven', 'photoframe', 'coffe_maker', 'food_food', 'television', 'food_onion', 'coffee_pot', 'sink', 'bathroom_cabinet', 'light', 'dishwasher', 'vase']
Task:Wash dishes with dishwasher
response:

[WALK] <dining_room>
[WALK] <bowl>
[FIND] <bowl>
[GRAB] <bowl>
[WALK] <dining_room>
[WASH] <bowl>
[WALK] <detergent>
[FIND] <detergent>
[RINSE] <detergent>