Où l'on déboucle la boucle de la boucle

difficulty = (
	"easy" if len(self.curriculum_agent.completed_tasks) > 15 else "peaceful"
)

# step to peek an observation
events = self.env.step(
	"bot.chat(`/time set ${getNextTime()}`);\n"
	+ f"bot.chat('/difficulty {difficulty}');"
)

self.vectordb.add_texts(
	texts=[skill_description],
	ids=[program_name],
	metadatas=[{"name": program_name}],
)

skills = self.skill_manager.retrieve_skills(query=self.context)

{
	"mineWoodLog": {
		"code": "async function mineWoodLog(bot) {
		  const woodLogNames = [\"oak_log\", \"birch_log\", \"spruce_log\", \"jungle_log\", \"acacia_log\", \"dark_oak_log\", \"mangrove_log\"];

		  // Find a wood log block
		  const woodLogBlock = await exploreUntil(bot, new Vec3(1, 0, 1), 60, () => {
			return bot.findBlock({
			  matching: block => woodLogNames.includes(block.name),
			  maxDistance: 32
			});
		  });
		  if (!woodLogBlock) {
			bot.chat(\"Could not find a wood log.\");
			return;
		  }

		  // Mine the wood log block
		  await mineBlock(bot, woodLogBlock.name, 1);
		  bot.chat(\"Wood log mined.\");
		}",
		"description": "async function mineWoodLog(bot) {
			// The function is about mining a single wood log block. It searches for a wood log block by exploring the environment until it finds one of the seven types of wood logs. If a wood log block is found, it is mined and a success message is sent. If no wood log block is found, a failure message is sent.
		}"
}

# FIXME: Hardcoded control_primitives
base_skills = [
	"exploreUntil",
	"mineBlock",
	"craftItem",
	"placeItem",
	"smeltItem",
	"killMob",
]
if not self.llm.model_name == "gpt-3.5-turbo":
	base_skills += [
		"useChest",
		"mineflayer",
	]
programs = "\n\n".join(load_control_primitives_context(base_skills) + skills)

• le code JavaScript des compétences tirées de la base de données vectorielles, qui vient d'être interrogée pour récupérer les compétences en rapport avec le contexte de la tâche – la manière de s'y prendre pour réaliser la tâche, comme "You can mine one of oak, birch, spruce, jungle, acacia, dark oak, or mangrove logs." ;
• le code JavaScript tiré de différents fichiers, la fonction load_control_primitives_context () ne faisant que retourner le contenu des fichiers d'extension ".js" qui figurent dans le répertoire /control_primitives_context/ dont les noms lui sont passés (/control_primitives_context/__init__.py).

// Kill a pig and collect the dropped item: killMob(bot, "pig", 300);
async function killMob(bot, mobName, timeout = 300) {
    const entity = bot.nearestEntity(
        (entity) =>
            entity.name === mobName &&
            entity.position.distanceTo(bot.entity.position) < 32
    );
    await bot.pvp.attack(entity);
    await bot.pathfinder.goto(
        new GoalBlock(entity.position.x, entity.position.y, entity.position.z)
    );
}

await bot.pathfinder.goto(goal); // A very useful function. This function may change your main-hand equipment.
// Following are some Goals you can use:
new GoalNear(x, y, z, range); // Move the bot to a block within the specified range of the specified block. `x`, `y`, `z`, and `range` are `number`

Explain: ...
Plan:
1) ...
2) ...
3) ...
...
Code:
```javascript
// helper functions (only if needed, try to avoid them)
...
// main function after the helper functions
async function yourMainFunctionName(bot) {
  // ...
}
```

if not (
	task == "Place and deposit useless items into a chest"
	or task.startswith("Deposit useless items into the chest at")
):
	observation += self.render_chest_observation()

Un paquet de compétences

while True:
	messages, reward, done, info = self.step()
	if done:
		break

from javascript import require

babel = require("@babel/core")
#...
parsed = babel.parse(code)

"await (<fonction>) (bot);"

def programs(self):
	programs = ""
	for skill_name, entry in self.skills.items():
		programs += f"{entry['code']}\n\n"
	for primitives in self.control_primitives:
		programs += f"{primitives}\n\n"
	return programs

self.skills[program_name] = {
	"code": program_code,
	"description": skill_description,
}

self.control_primitives = load_control_primitives()

async function killMob(bot, mobName, timeout = 300) {
    // return if mobName is not string
    if (typeof mobName !== "string") {
        throw new Error(`mobName for killMob must be a string`);
    }
    // return if timeout is not number
    if (typeof timeout !== "number") {
        throw new Error(`timeout for killMob must be a number`);
    }

    const weaponsForShooting = [
        "bow",
        "crossbow",
        "snowball",
        "ender_pearl",
        "egg",
        "splash_potion",
        "trident",
    ];
    const mainHandItem = bot.inventory.slots[bot.getEquipmentDestSlot("hand")];

    const entity = bot.nearestEntity(
        (entity) =>
            entity.name === mobName &&
            // kill mob distance should be slightly bigger than explore distance
            entity.position.distanceTo(bot.entity.position) < 48
    );
    if (!entity) {
        bot.chat(`No ${mobName} nearby, please explore first`);
        _killMobFailCount++;
        if (_killMobFailCount > 10) {
            throw new Error(
                `killMob failed too many times, make sure you explore before calling killMob`
            );
        }
        return;
    }

    let droppedItem;
    if (mainHandItem && weaponsForShooting.includes(mainHandItem.name)) {
        bot.hawkEye.autoAttack(entity, mainHandItem.name);
        droppedItem = await waitForMobShot(bot, entity, timeout);
    } else {
        await bot.pvp.attack(entity);
        droppedItem = await waitForMobRemoved(bot, entity, timeout);
    }
    if (droppedItem) {
        await bot.collectBlock.collect(droppedItem, { ignoreNoPath: true });
    }
    bot.save(`${mobName}_killed`);
}

• code, le code JavaScript généré par le LLM pour accomplir la tâche, suivi de la ligne de code qui appelle la dernière des fonctions asynchrones qui ne prennent que bot en paramètre, censée accomplir ce miracle ;
• programs, le code JavaScript des compétences que ce code appelle éventuellement, récupéré après avoir interrogé la base de données vectorielle sur les compétences pertinentes au regard du contexte de la tâche – la manière de l'accomplir –, et le code JavaScript des compétences prédéfinies tiré des fichiers d'extension ".js" de /control_primitives/.

Enfin, de l'action !

data = {
	"code": code,
	"programs": programs,
}

const r = await evaluateCode(code, programs);

try {
	await eval("(async () => {" + programs + "\n" + code + "})()");
	return "success";
} catch (err) {
	return err;
}

La critique des critiques

• il donne un rôle au LLM :

  You are an assistant that assesses my progress of playing Minecraft and provides useful guidance.
  
  You are required to evaluate if I have met the task requirements. Exceeding the task requirements is also considered a success while failing to meet them requires you to provide critique to help me improve.
  

• il lui décrit les informations qu'il va lui fournir, c'est-à-dire les états du bot et de son environnement, ainsi que l'énoncé de la tâche et son contexte (extrait) :

  Biome: The biome after the task execution.
  Time: The current time.
  <...>
  Task: The objective I need to accomplish.
  Context: The context of the task.
  

• il lui indique quel format sa réponse doit respecter :

  You should only respond in JSON format as described below:
  {
  	"reasoning": "reasoning",
  	"success": boolean,
  	"critique": "critique",
  }
  Ensure the response can be parsed by Python `json.loads`, e.g.: no trailing commas, no single quotes, etc.
  

• il lui donne un série d'exemples (extrait) :

  Here are some examples:
  INPUT:
  Inventory (2/36): {'oak_log':2, 'spruce_log':2}
  
  Task: Mine 3 wood logs
  
  RESPONSE:
  {
  	"reasoning": "You need to mine 3 wood logs. You have 2 oak logs and 2 spruce logs, which add up to 4 wood logs.",
  	"success": true,
  	"critique": ""
  }
  <...>
  

Biome: sparse jungle

Time: sunrise

Nearby blocks: dirt, andesite, cobblestone

Health: 4.0/20

Hunger: 6.0/20

Position: x=1.0, y=143.0, z=45.0

Equipment: ['iron_helmet', 'diamond_chestplate', 'iron_leggings', 'iron_boots', 'iron_sword', 'torch']

Inventory (2/36): {'golden_apple': 2, 'diamond': 12}

Chests:
(1.1, -12.0, 7.2): {'iron_axe': 2, 'apple': 1, 'tnt': 4}
(-6.0, 12.3, 4.2): Unknown items inside
(3.5, 5.1, -2.0): Empty

Task: Craft 1 chest

Context: Craft 1 chest with 8 planks of any kind of wood.

Feedback sur le prompt

bot._chat = bot.chat;
bot.chat = (message) => {
	// action_count.chat++;
	bot.emit("chatEvent", "bot", message);
	bot._chat(message);
};

def filter_item(message: str):
	craft_pattern = r"I cannot make \w+ because I need: (.*)"
	craft_pattern2 = (
		r"I cannot make \w+ because there is no crafting table nearby"
	)
	mine_pattern = r"I need at least a (.*) to mine \w+!"
	if re.match(craft_pattern, message):
		return re.match(craft_pattern, message).groups()[0]
	elif re.match(craft_pattern2, message):
		return "a nearby crafting table"
	elif re.match(mine_pattern, message):
		return re.match(mine_pattern, message).groups()[0]
	else:
		return ""

chatlog = set()
for event_type, event in events:
	if event_type == "onChat":
		item = filter_item(event["onChat"])
		if item:
			chatlog.add(item)
return "I also need " + ", ".join(chatlog) + "." if chatlog else ""

Craft 1 chest with 8 planks of any kind of wood.

I also need 3 planks, a nearby crafting table.

system_message = self.action_agent.render_system_message(skills=new_skills)
human_message = self.action_agent.render_human_message(
	events=events,
	code=parsed_result["program_code"],
	task=self.task,
	context=self.context,
	critique=critique,
)
self.last_events = copy.deepcopy(events)
self.messages = [system_message, human_message]

• messages, un tableau qui contient les prompts système et utilisateur mis à jour ;
• reward, une constante à 0 ;
• done, un drapeau à True si la tâche a pu être accomplie, ou si cela n'a pas été possible dans la limite du nombre de tentatives autorisées ;
• info, un dictionnaire qui reprend :
  • l'énoncé de la tâche ;
  • le booléen retourné par CriticAgent.check_task_success () qui acte de sa réussite ou de son échec de son accomplissement par le bot :
  • Voyager.conversations – pour rappel, une liste de tuples formés du prompt système, du prompt utilisateur et de la réponse du LLM ;
  • le code JavaScript généré par le LLM ;
  • le nom de la dernière fonction asynchrone qui ne prend que bot en paramètre trouvée dans ce code.

"Je l'aurai ! Un jour, je l'aurai !"

Les leçons de la vie

info = {
	"task": <énoncé de la tâche>,
	"success": <booléen à True si le bot a réussi à accomplir la tâche>,
	"conversations": [
		( <prompt système>, <prompt utilisateur>, <réponse du LLM> ),
		<...>
	],
	"program_code": <code JavaScript généré par le LLM>,
	"program_name": <nom de la dernière fonction asychrone qui ne prend que bot en paramètre trouvée dans ce code>
}

• dans la base de données vectorielle des compétences, c'est une entrée qui comprend les champs suivants :

  texts=<description de la fonction en six phrases au plus sur une ligne>
  ids=<nom d'une fonction asynchrone qui ne prend que bot en paramètre>
  metadatas=[{"name": <nom de la focntion asynchrone>}]
  

• dans le fichier /ckpt/skill/skills.json, c'est une entrée au format suivant dans un dictionnaire :

  <nom de la fonction asynchrone qui ne prend que bot en paramètre>: {
  	"code": <code JavaScript de la fonction>,
  	"description": <description de la fonction en six phrases au plus sur une ligne>
  }
  

• il donne un rôle au LLM :

  You are a helpful assistant that writes a description of the given function written in Mineflayer javascript code.
  

• il lui donne des règles à respecter :

  1) Do not mention the function name.
  2) Do not mention anything about `bot.chat` or helper functions.
  3) There might be some helper functions before the main function, but you only need to describe the main function.
  4) Try to summarize the function in no more than 6 sentences.
  5) Your response should be a single line of text.
  

• il lui donne un exemple (extrait) :

  For example, if the function is:
  
  async function mineCobblestone(bot) {
  	<...>
  }
  
  The main function is `mineCobblestone`.
  
  Then you would write:
  
  The function is about mining 8 cobblestones using a wooden pickaxe. First check if a wooden pickaxe is in the inventory. If not, craft one. If the wooden pickaxe is available, equip the wooden pickaxe in the hand. Next, explore the environment until finding a stone block. Once a stone block is found, mine a total of 8 cobblestone blocks using the wooden pickaxe.
  

Completed tasks so far: <concaténation des entrées de CurriculumAgent.competed_tasks séparées par une virgule>
Failed tasks that are too hard: <concaténation des entrées de CurriculumAgent.failed_tasks séparées par une virgule>

Il reste des bouts de code, ici et là

├── action
│   └── chest_memory.json
├── curriculum
│   ├── completed_tasks.json
│   ├── failed_tasks.json
│   ├── qa_cache.json
│   └── vectordb
├── events
└── skill
    ├── code
    │   ├── catchThreeFishWithCheck.js
    │   ├── collectBamboo.js
    │   ├── ...
    ├── description
    │   ├── catchThreeFishWithCheck.txt
    │   ├── collectBamboo.txt
    │   └── ...
    ├── skills.json
    └── vectordb