mindcraft 0.1.4-0

package/settings.js

@@ -0,0 +1,64 @@
+const settings = {
+    "minecraft_version": "auto", // or specific version like "1.21.6"
+    "host": "127.0.0.1", // or "localhost", "your.ip.address.here"
+    "port": 55916, // set to -1 to automatically scan for open ports
+    "auth": "offline", // or "microsoft"
+    "data_dir": "./bots", // where bot memories, histories, screenshots, and generated code are written
+
+    // the mindserver manages all agents and hosts the UI
+    "mindserver_port": 8080,
+    "auto_open_ui": true, // opens UI in browser on startup
+    
+    "base_profile": "assistant", // survival, assistant, creative, or god_mode
+    "profiles": [
+        "./andy.json",
+        // "./profiles/gpt.json",
+        // "./profiles/claude.json",
+        // "./profiles/gemini.json",
+        // "./profiles/llama.json",
+        // "./profiles/qwen.json",
+        // "./profiles/grok.json",
+        // "./profiles/mistral.json",
+        // "./profiles/deepseek.json",
+        // "./profiles/mercury.json",
+        // "./profiles/andy-4.json", // Supports up to 75 messages!
+
+        // using more than 1 profile requires you to /msg each bot indivually
+        // individual profiles override values from the base profile
+    ],
+
+    "load_memory": false, // load memory from previous session
+    "init_message": "Respond with hello world and your name", // sends to all on spawn
+    "only_chat_with": [], // users that the bots listen to and send general messages to. if empty it will chat publicly
+
+    "speak": false,
+    // allows all bots to speak through text-to-speech. 
+    // specify speech model inside each profile with format: {provider}/{model}/{voice}.
+    // if set to "system" it will use basic system text-to-speech. 
+    // Works on windows and mac, but linux requires you to install the espeak package through your package manager eg: `apt install espeak` `pacman -S espeak`.
+
+    "chat_ingame": true, // bot responses are shown in minecraft chat
+    "language": "en", // translate to/from this language. Supports these language names: https://cloud.google.com/translate/docs/languages
+    "render_bot_view": false, // show bot's view in browser at localhost:3000, 3001...
+
+    "allow_insecure_coding": false, // allows newAction command and model can write/run code on your computer. enable at own risk
+    "allow_vision": false, // allows vision model to interpret screenshots as inputs
+    "blocked_actions" : ["!checkBlueprint", "!checkBlueprintLevel", "!getBlueprint", "!getBlueprintLevel"] , // commands to disable and remove from docs. Ex: ["!setMode"]
+    "code_timeout_mins": -1, // minutes code is allowed to run. -1 for no timeout
+    "relevant_docs_count": 5, // number of relevant code function docs to select for prompting. -1 for all
+
+    "max_messages": 15, // max number of messages to keep in context
+    "num_examples": 2, // number of examples to give to the model
+    "max_commands": -1, // max number of commands that can be used in consecutive responses. -1 for no limit
+    "show_command_syntax": "full", // "full", "shortened", or "none"
+    "narrate_behavior": true, // chat simple automatic actions ('Picking up item!')
+    "chat_bot_messages": true, // publicly chat messages to other bots
+
+    "spawn_timeout": 30, // num seconds allowed for the bot to spawn before throwing error. Increase when spawning takes a while.
+    "block_place_delay": 0, // delay between placing blocks (ms) if using newAction. helps avoid bot being kicked by anti-cheat mechanisms on servers.
+  
+    "log_all_prompts": false, // log ALL prompts to file
+
+}
+
+export default settings;

package/src/agent/action_manager.js

@@ -0,0 +1,177 @@
+export class ActionManager {
+    constructor(agent) {
+        this.agent = agent;
+        this.executing = false;
+        this.currentActionLabel = '';
+        this.currentActionFn = null;
+        this.timedout = false;
+        this.resume_func = null;
+        this.resume_name = '';
+        this.last_action_time = 0;
+        this.recent_action_counter = 0;
+    }
+
+    async resumeAction(actionFn, timeout) {
+        return this._executeResume(actionFn, timeout);
+    }
+
+    async runAction(actionLabel, actionFn, { timeout, resume = false } = {}) {
+        if (resume) {
+            return this._executeResume(actionLabel, actionFn, timeout);
+        } else {
+            return this._executeAction(actionLabel, actionFn, timeout);
+        }
+    }
+
+    async stop() {
+        if (!this.executing) return;
+        const timeout = setTimeout(() => {
+            this.agent.cleanKill('Code execution refused stop after 10 seconds. Killing process.');
+        }, 10000);
+        while (this.executing) {
+            this.agent.requestInterrupt();
+            console.log('waiting for code to finish executing...');
+            await new Promise(resolve => setTimeout(resolve, 300));
+        }
+        clearTimeout(timeout);
+    } 
+
+    cancelResume() {
+        this.resume_func = null;
+        this.resume_name = null;
+    }
+
+    async _executeResume(actionLabel = null, actionFn = null, timeout = 10) {
+        const new_resume = actionFn != null;
+        if (new_resume) { // start new resume
+            this.resume_func = actionFn;
+            assert(actionLabel != null, 'actionLabel is required for new resume');
+            this.resume_name = actionLabel;
+        }
+        if (this.resume_func != null && (this.agent.isIdle() || new_resume) && (!this.agent.self_prompter.isActive() || new_resume)) {
+            this.currentActionLabel = this.resume_name;
+            let res = await this._executeAction(this.resume_name, this.resume_func, timeout);
+            this.currentActionLabel = '';
+            return res;
+        } else {
+            return { success: false, message: null, interrupted: false, timedout: false };
+        }
+    }
+
+    async _executeAction(actionLabel, actionFn, timeout = 10) {
+        let TIMEOUT;
+        try {
+            if (this.last_action_time > 0) {
+                let time_diff = Date.now() - this.last_action_time;
+                if (time_diff < 20) {
+                    this.recent_action_counter++;
+                }
+                else {
+                    this.recent_action_counter = 0;
+                }
+                if (this.recent_action_counter > 3) {
+                    console.warn('Fast action loop detected, cancelling resume.');
+                    this.cancelResume(); // likely cause of repetition
+                }
+                if (this.recent_action_counter > 5) {
+                    console.error('Infinite action loop detected, shutting down.');
+                    this.agent.cleanKill('Infinite action loop detected, shutting down.');
+                    return { success: false, message: 'Infinite action loop detected, shutting down.', interrupted: false, timedout: false };
+                }
+            }
+            this.last_action_time = Date.now();
+            console.log('executing code...\n');
+
+            // await current action to finish (executing=false), with 10 seconds timeout
+            // also tell agent.bot to stop various actions
+            if (this.executing) {
+                console.log(`action "${actionLabel}" trying to interrupt current action "${this.currentActionLabel}"`);
+            }
+            await this.stop();
+
+            // clear bot logs and reset interrupt code
+            this.agent.clearBotLogs();
+
+            this.executing = true;
+            this.currentActionLabel = actionLabel;
+            this.currentActionFn = actionFn;
+
+            // timeout in minutes
+            if (timeout > 0) {
+                TIMEOUT = this._startTimeout(timeout);
+            }
+
+            // start the action
+            await actionFn();
+
+            // mark action as finished + cleanup
+            this.executing = false;
+            this.currentActionLabel = '';
+            this.currentActionFn = null;
+            clearTimeout(TIMEOUT);
+
+            // get bot activity summary
+            let output = this.getBotOutputSummary();
+            let interrupted = this.agent.bot.interrupt_code;
+            let timedout = this.timedout;
+            this.agent.clearBotLogs();
+
+            // if not interrupted and not generating, emit idle event
+            if (!interrupted) {
+                this.agent.bot.emit('idle');
+            }
+
+            // return action status report
+            return { success: true, message: output, interrupted, timedout };
+        } catch (err) {
+            this.executing = false;
+            this.currentActionLabel = '';
+            this.currentActionFn = null;
+            clearTimeout(TIMEOUT);
+            this.cancelResume();
+            console.error("Code execution triggered catch:", err);
+            // Log the full stack trace
+            console.error(err.stack);
+            await this.stop();
+            err = err.toString();
+
+            let message = this.getBotOutputSummary() +
+                '!!Code threw exception!!\n' +
+                'Error: ' + err + '\n' +
+                'Stack trace:\n' + err.stack+'\n';
+
+            let interrupted = this.agent.bot.interrupt_code;
+            this.agent.clearBotLogs();
+            if (!interrupted) {
+                this.agent.bot.emit('idle');
+            }
+            return { success: false, message, interrupted, timedout: false };
+        }
+    }
+
+    getBotOutputSummary() {
+        const { bot } = this.agent;
+        if (bot.interrupt_code && !this.timedout) return '';
+        let output = bot.output;
+        const MAX_OUT = 500;
+        if (output.length > MAX_OUT) {
+            output = `Action output is very long (${output.length} chars) and has been shortened.\n
+          First outputs:\n${output.substring(0, MAX_OUT / 2)}\n...skipping many lines.\nFinal outputs:\n ${output.substring(output.length - MAX_OUT / 2)}`;
+        }
+        else {
+            output = 'Action output:\n' + output.toString();
+        }
+        bot.output = '';
+        return output;
+    }
+
+    _startTimeout(TIMEOUT_MINS = 10) {
+        return setTimeout(async () => {
+            console.warn(`Code execution timed out after ${TIMEOUT_MINS} minutes. Attempting force stop.`);
+            this.timedout = true;
+            this.agent.history.add('system', `Code execution timed out after ${TIMEOUT_MINS} minutes. Attempting force stop.`);
+            await this.stop(); // last attempt to stop
+        }, TIMEOUT_MINS * 60 * 1000);
+    }
+
+}