mindcraft 0.1.4-0

package/src/agent/connection_handler.js

@@ -0,0 +1,96 @@
+import { sendOutputToServer } from './mindserver_proxy.js';
+
+// Definitions of error types, keywords, and full human-readable messages.
+const ERROR_DEFINITIONS = {
+    'name_conflict': {
+        keywords: ['name_taken', 'duplicate_login', 'already connected', 'already logged in', 'username is already'],
+        msg: 'Name Conflict: The name is already in use or you are already logged in.',
+        isFatal: true
+    },
+    'access_denied': {
+        keywords: ['whitelist', 'not white-listed', 'banned', 'suspended', 'verify'],
+        msg: 'Access Denied: You are not whitelisted or banned.',
+        isFatal: true
+    },
+    'server_full': {
+        keywords: ['server is full', 'full server'],
+        msg: 'Connection Failed: The server is full.',
+        isFatal: false
+    },
+    'version_mismatch': {
+        keywords: ['outdated', 'version', 'client'],
+        msg: 'Version Mismatch: Client and server versions do not match.',
+        isFatal: true
+    },
+    'maintenance': {
+        keywords: ['maintenance', 'updating', 'closed', 'restarting'],
+        msg: 'Connection Failed: Server is under maintenance or restarting.',
+        isFatal: false
+    },
+    'network_error': {
+        keywords: ['timeout', 'timed out', 'connection lost', 'reset', 'refused', 'keepalive'],
+        msg: 'Network Error: Connection timed out or was lost.',
+        isFatal: false
+    },
+    'behavior': {
+        keywords: ['flying', 'spam', 'speed'],
+        msg: 'Kicked: Removed from server due to flying, spamming, or invalid movement.',
+        isFatal: true
+    }
+};
+
+// Helper to log messages to console (once) and MindServer.
+export const log = (agentName, msg) => {
+    // Use console.error for visibility in terminal
+    console.error(msg);
+    try { sendOutputToServer(agentName || 'system', msg); } catch (_) {}
+};
+
+// Analyzes the kick reason and returns a full, human-readable sentence.
+export function parseKickReason(reason) {
+    if (!reason) return { type: 'unknown', msg: 'Unknown reason (Empty)', isFatal: true };
+    
+    const raw = (typeof reason === 'string' ? reason : JSON.stringify(reason)).toLowerCase();
+
+    // Search for keywords in definitions
+    for (const [type, def] of Object.entries(ERROR_DEFINITIONS)) {
+        if (def.keywords.some(k => raw.includes(k))) {
+            console.error(`Disconnected: ${raw}`);
+            return { type, msg: def.msg, isFatal: def.isFatal };
+        }
+    }
+    
+    // Fallback: Extract text from JSON
+    let fallback = raw;
+    try {
+        const obj = typeof reason === 'string' ? JSON.parse(reason) : reason;
+        fallback = obj.translate || obj.text || (obj.value?.translate) || raw;
+    } catch (_) {}
+    
+    return { type: 'other', msg: `Disconnected: ${fallback}`, isFatal: true };
+}
+
+// Centralized handler for disconnections.
+export function handleDisconnection(agentName, reason) {
+    const { type, msg } = parseKickReason(reason);
+    
+    // Format: [LoginGuard] Error Message
+    const finalMsg = `[LoginGuard] ${msg}`;
+    
+    // Only call log once (it handles console printing)
+    log(agentName, finalMsg);
+    
+    return { type, msg: finalMsg };
+}
+
+// Validates name format.
+export function validateNameFormat(name) {
+    if (!name || !/^[a-zA-Z0-9_]{3,16}$/.test(name)) {
+        return { 
+            success: false, 
+            // Added [LoginGuard] prefix here for consistency
+            msg: `[LoginGuard] Invalid name '${name}'. Must be 3-16 alphanumeric/underscore characters.` 
+        };
+    }
+    return { success: true };
+}

package/src/agent/conversation.js

@@ -0,0 +1,353 @@
+import settings from './settings.js';
+import { containsCommand } from './commands/index.js';
+import { sendBotChatToServer } from './mindserver_proxy.js';
+
+let agent;
+let agent_names = [];
+let agents_in_game = [];
+
+class Conversation {
+    constructor(name) {
+        this.name = name;
+        this.active = false;
+        this.ignore_until_start = false;
+        this.blocked = false;
+        this.in_queue = [];
+        this.inMessageTimer = null;
+    }
+
+    reset() {
+        this.active = false;
+        this.ignore_until_start = false;
+        this.in_queue = [];
+        this.inMessageTimer = null;
+    }
+
+    end() {
+        this.active = false;
+        this.ignore_until_start = true;
+        this.inMessageTimer = null;
+        const full_message = _compileInMessages(this);
+        if (full_message.message.trim().length > 0)
+            agent.history.add(this.name, full_message.message);
+        // add the full queued messages to history, but don't respond
+
+        if (agent.last_sender === this.name)
+            agent.last_sender = null;
+    }
+
+    queue(message) {
+        this.in_queue.push(message);
+    }
+}
+
+const WAIT_TIME_START = 30000;
+class ConversationManager {
+    constructor() {
+        this.convos = {};
+        this.activeConversation = null;
+        this.awaiting_response = false;
+        this.connection_timeout = null;
+        this.wait_time_limit = WAIT_TIME_START;
+    }
+
+    initAgent(a) {
+        agent = a;
+    }
+
+    _getConvo(name) {
+        if (!this.convos[name])
+            this.convos[name] = new Conversation(name);
+        return this.convos[name];
+    }
+
+    _startMonitor() {
+        clearInterval(this.connection_monitor);
+        let wait_time = 0;
+        let last_time = Date.now();
+        this.connection_monitor = setInterval(() => {
+            if (!this.activeConversation) {
+                this._stopMonitor();
+                return; // will clean itself up
+            }
+
+            let delta = Date.now() - last_time;
+            last_time = Date.now();
+            let convo_partner = this.activeConversation.name;
+
+            if (this.awaiting_response && agent.isIdle()) {
+                wait_time += delta;
+                if (wait_time > this.wait_time_limit) {
+                    agent.handleMessage('system', `${convo_partner} hasn't responded in ${this.wait_time_limit/1000} seconds, respond with a message to them or your own action.`);
+                    wait_time = 0;
+                    this.wait_time_limit*=2;
+                }
+            }
+            else if (!this.awaiting_response){
+                this.wait_time_limit = WAIT_TIME_START;
+                wait_time = 0;
+            }
+
+            if (!this.otherAgentInGame(convo_partner) && !this.connection_timeout) {
+                this.connection_timeout = setTimeout(() => {
+                    if (this.otherAgentInGame(convo_partner)){
+                        this._clearMonitorTimeouts();
+                        return;
+                    }
+                    if (!agent.self_prompter.isPaused()) {
+                        this.endConversation(convo_partner);
+                        agent.handleMessage('system', `${convo_partner} disconnected, conversation has ended.`);
+                    }
+                    else {
+                        this.endConversation(convo_partner);
+                    }
+                }, 10000);
+            }
+        }, 1000);
+    }
+
+    _stopMonitor() {
+        clearInterval(this.connection_monitor);
+        this.connection_monitor = null;
+        this._clearMonitorTimeouts();
+    }
+
+    _clearMonitorTimeouts() {
+        this.awaiting_response = false;
+        clearTimeout(this.connection_timeout);
+        this.connection_timeout = null;
+    }
+
+    async startConversation(send_to, message) {
+        const convo = this._getConvo(send_to);
+        convo.reset();
+        
+        if (agent.self_prompter.isActive()) {
+            await agent.self_prompter.pause();
+        }
+        if (convo.active)
+            return;
+        convo.active = true;
+        this.activeConversation = convo;
+        this._startMonitor();
+        this.sendToBot(send_to, message, true, false);
+    }
+
+    startConversationFromOtherBot(name) {
+        const convo = this._getConvo(name);
+        convo.active = true;
+        this.activeConversation = convo;
+        this._startMonitor();
+    }
+
+    sendToBot(send_to, message, start=false, open_chat=true) {
+        if (!this.isOtherAgent(send_to)) {
+            console.warn(`${agent.name} tried to send bot message to non-bot ${send_to}`);
+            return;
+        }
+        const convo = this._getConvo(send_to);
+        
+        if (settings.chat_bot_messages && open_chat)
+            agent.openChat(`(To ${send_to}) ${message}`);
+        
+        if (convo.ignore_until_start)
+            return;
+        convo.active = true;
+        
+        const end = message.includes('!endConversation');
+        const json = {
+            'message': message,
+            start,
+            end,
+        };
+
+        this.awaiting_response = true;
+        sendBotChatToServer(send_to, json);
+    }
+
+    async receiveFromBot(sender, received) {
+        const convo = this._getConvo(sender);
+
+        if (convo.ignore_until_start && !received.start)
+            return;
+
+        // check if any convo is active besides the sender
+        if (this.inConversation() && !this.inConversation(sender)) {
+            this.sendToBot(sender, `I'm talking to someone else, try again later. !endConversation("${sender}")`, false, false);
+            this.endConversation(sender);
+            return;
+        }
+
+        if (received.start) {
+            convo.reset();
+            this.startConversationFromOtherBot(sender);
+        }
+
+        this._clearMonitorTimeouts();
+        convo.queue(received);
+        
+        // responding to conversation takes priority over self prompting
+        if (agent.self_prompter.isActive()){
+            await agent.self_prompter.pause();
+        }
+    
+        _scheduleProcessInMessage(sender, received, convo);
+    }
+
+    responseScheduledFor(sender) {
+        if (!this.isOtherAgent(sender) || !this.inConversation(sender))
+            return false;
+        const convo = this._getConvo(sender);
+        return !!convo.inMessageTimer;
+    }
+
+    isOtherAgent(name) {
+        return agent_names.some((n) => n === name);
+    }
+
+    otherAgentInGame(name) {
+        return agents_in_game.some((n) => n === name);
+    }
+    
+    updateAgents(agents) {
+        agent_names = agents.map(a => a.name);
+        agents_in_game = agents.filter(a => a.in_game).map(a => a.name);
+    }
+
+    getInGameAgents() {
+        return agents_in_game;
+    }
+    
+    inConversation(other_agent=null) {
+        if (other_agent)
+            return this.convos[other_agent]?.active;
+        return Object.values(this.convos).some(c => c.active);
+    }
+    
+    endConversation(sender) {
+        if (this.convos[sender]) {
+            this.convos[sender].end();
+            if (this.activeConversation.name === sender) {
+                this._stopMonitor();
+                this.activeConversation = null;
+                if (agent.self_prompter.isPaused() && !this.inConversation()) {
+                    _resumeSelfPrompter();
+                }
+            }
+        }
+    }
+    
+    endAllConversations() {
+        for (const sender in this.convos) {
+            this.endConversation(sender);
+        }
+        if (agent.self_prompter.isPaused()) {
+            _resumeSelfPrompter();
+        }
+    }
+
+    forceEndCurrentConversation() {
+        if (this.activeConversation) {
+            let sender = this.activeConversation.name;
+            this.sendToBot(sender, '!endConversation("' + sender + '")', false, false);
+            this.endConversation(sender);
+        }
+    }
+}
+
+const convoManager = new ConversationManager();
+export default convoManager;
+
+/*
+This function controls conversation flow by deciding when the bot responds.
+The logic is as follows:
+- If neither bot is busy, respond quickly with a small delay.
+- If only the other bot is busy, respond with a long delay to allow it to finish short actions (ex check inventory)
+- If I'm busy but other bot isn't, let LLM decide whether to respond
+- If both bots are busy, don't respond until someone is done, excluding a few actions that allow fast responses
+- New messages received during the delay will reset the delay following this logic, and be queued to respond in bulk
+*/
+const talkOverActions = ['stay', 'followPlayer', 'mode:']; // all mode actions
+const fastDelay = 200;
+const longDelay = 5000;
+async function _scheduleProcessInMessage(sender, received, convo) {
+    if (convo.inMessageTimer)
+        clearTimeout(convo.inMessageTimer);
+    let otherAgentBusy = containsCommand(received.message);
+
+    const scheduleResponse = (delay) => convo.inMessageTimer = setTimeout(() => _processInMessageQueue(sender), delay);
+
+    if (!agent.isIdle() && otherAgentBusy) {
+        // both are busy
+        let canTalkOver = talkOverActions.some(a => agent.actions.currentActionLabel.includes(a));
+        if (canTalkOver)
+            scheduleResponse(fastDelay)
+        // otherwise don't respond
+    }
+    else if (otherAgentBusy)
+        // other bot is busy but I'm not
+        scheduleResponse(longDelay);
+    else if (!agent.isIdle()) {
+        // I'm busy but other bot isn't
+        let canTalkOver = talkOverActions.some(a => agent.actions.currentActionLabel.includes(a));
+        if (canTalkOver) {
+            scheduleResponse(fastDelay);
+        }
+        else {
+            let shouldRespond = await agent.prompter.promptShouldRespondToBot(received.message);
+            console.log(`${agent.name} decided to ${shouldRespond?'respond':'not respond'} to ${sender}`);
+            if (shouldRespond)
+                scheduleResponse(fastDelay);
+        }
+    }
+    else {
+        // neither are busy
+        scheduleResponse(fastDelay);
+    }
+}
+
+function _processInMessageQueue(name) {
+    const convo = convoManager._getConvo(name);
+    _handleFullInMessage(name, _compileInMessages(convo));
+}
+
+function _compileInMessages(convo) {
+    let pack = {};
+    let full_message = '';
+    while (convo.in_queue.length > 0) {
+        pack = convo.in_queue.shift();
+        full_message += pack.message;
+    }
+    pack.message = full_message;
+    return pack;
+}
+
+function _handleFullInMessage(sender, received) {
+    console.log(`${agent.name} responding to "${received.message}" from ${sender}`);
+    
+    const convo = convoManager._getConvo(sender);
+    convo.active = true;
+
+    let message = _tagMessage(received.message);
+    if (received.end) {
+        convoManager.endConversation(sender);
+        message = `Conversation with ${sender} ended with message: "${message}"`;
+        sender = 'system'; // bot will respond to system instead of the other bot
+    }
+    else if (received.start)
+        agent.shut_up = false;
+    convo.inMessageTimer = null;
+    agent.handleMessage(sender, message);
+}
+
+
+function _tagMessage(message) {
+    return "(FROM OTHER BOT)" + message;
+}
+
+async function _resumeSelfPrompter() {
+    await new Promise(resolve => setTimeout(resolve, 5000));
+    if (agent.self_prompter.isPaused() && !convoManager.inConversation()) {
+        agent.self_prompter.start();
+    }
+}

package/src/agent/history.js

@@ -0,0 +1,122 @@
+import { writeFileSync, readFileSync, mkdirSync, existsSync } from 'fs';
+import { NPCData } from './npc/data.js';
+import settings from './settings.js';
+
+
+export class History {
+    constructor(agent) {
+        this.agent = agent;
+        this.name = agent.name;
+        this.bot_dir = `${settings.data_dir}/${this.name}`;
+        this.memory_fp = `${this.bot_dir}/memory.json`;
+        this.full_history_fp = undefined;
+
+        mkdirSync(`${this.bot_dir}/histories`, { recursive: true });
+
+        this.turns = [];
+
+        // Natural language memory as a summary of recent messages + previous memory
+        this.memory = '';
+
+        // Maximum number of messages to keep in context before saving chunk to memory
+        this.max_messages = settings.max_messages;
+
+        // Number of messages to remove from current history and save into memory
+        this.summary_chunk_size = 5; 
+        // chunking reduces expensive calls to promptMemSaving and appendFullHistory
+        // and improves the quality of the memory summary
+    }
+
+    getHistory() { // expects an Examples object
+        return JSON.parse(JSON.stringify(this.turns));
+    }
+
+    async summarizeMemories(turns) {
+        console.log("Storing memories...");
+        this.memory = await this.agent.prompter.promptMemSaving(turns);
+
+        if (this.memory.length > 500) {
+            this.memory = this.memory.slice(0, 500);
+            this.memory += '...(Memory truncated to 500 chars. Compress it more next time)';
+        }
+
+        console.log("Memory updated to: ", this.memory);
+    }
+
+    async appendFullHistory(to_store) {
+        if (this.full_history_fp === undefined) {
+            const string_timestamp = new Date().toLocaleString().replace(/[/:]/g, '-').replace(/ /g, '').replace(/,/g, '_');
+            this.full_history_fp = `${this.bot_dir}/histories/${string_timestamp}.json`;
+            writeFileSync(this.full_history_fp, '[]', 'utf8');
+        }
+        try {
+            const data = readFileSync(this.full_history_fp, 'utf8');
+            let full_history = JSON.parse(data);
+            full_history.push(...to_store);
+            writeFileSync(this.full_history_fp, JSON.stringify(full_history, null, 4), 'utf8');
+        } catch (err) {
+            console.error(`Error reading ${this.name}'s full history file: ${err.message}`);
+        }
+    }
+
+    async add(name, content) {
+        let role = 'assistant';
+        if (name === 'system') {
+            role = 'system';
+        }
+        else if (name !== this.name) {
+            role = 'user';
+            content = `${name}: ${content}`;
+        }
+        this.turns.push({role, content});
+
+        if (this.turns.length >= this.max_messages) {
+            let chunk = this.turns.splice(0, this.summary_chunk_size);
+            while (this.turns.length > 0 && this.turns[0].role === 'assistant')
+                chunk.push(this.turns.shift()); // remove until turns starts with system/user message
+
+            await this.summarizeMemories(chunk);
+            await this.appendFullHistory(chunk);
+        }
+    }
+
+    async save() {
+        try {
+            const data = {
+                memory: this.memory,
+                turns: this.turns,
+                self_prompting_state: this.agent.self_prompter.state,
+                self_prompt: this.agent.self_prompter.isStopped() ? null : this.agent.self_prompter.prompt,
+                taskStart: this.agent.task.taskStartTime,
+                last_sender: this.agent.last_sender
+            };
+            writeFileSync(this.memory_fp, JSON.stringify(data, null, 2));
+            console.log('Saved memory to:', this.memory_fp);
+        } catch (error) {
+            console.error('Failed to save history:', error);
+            throw error;
+        }
+    }
+
+    load() {
+        try {
+            if (!existsSync(this.memory_fp)) {
+                console.log('No memory file found.');
+                return null;
+            }
+            const data = JSON.parse(readFileSync(this.memory_fp, 'utf8'));
+            this.memory = data.memory || '';
+            this.turns = data.turns || [];
+            console.log('Loaded memory:', this.memory);
+            return data;
+        } catch (error) {
+            console.error('Failed to load history:', error);
+            throw error;
+        }
+    }
+
+    clear() {
+        this.turns = [];
+        this.memory = '';
+    }
+}

package/src/agent/library/full_state.js

@@ -0,0 +1,89 @@
+import { 
+    getPosition,
+    getBiomeName,
+    getNearbyPlayerNames,
+    getInventoryCounts,
+    getNearbyEntityTypes,
+    getBlockAtPosition,
+    getFirstBlockAboveHead
+} from "./world.js";
+import convoManager from '../conversation.js';
+
+export function getFullState(agent) {
+    const bot = agent.bot;
+
+    const pos = getPosition(bot);
+    const position = {
+        x: Number(pos.x.toFixed(2)),
+        y: Number(pos.y.toFixed(2)),
+        z: Number(pos.z.toFixed(2))
+    };
+
+    let weather = 'Clear';
+    if (bot.thunderState > 0) weather = 'Thunderstorm';
+    else if (bot.rainState > 0) weather = 'Rain';
+
+    let timeLabel = 'Night';
+    if (bot.time.timeOfDay < 6000) timeLabel = 'Morning';
+    else if (bot.time.timeOfDay < 12000) timeLabel = 'Afternoon';
+
+    const below = getBlockAtPosition(bot, 0, -1, 0).name;
+    const legs = getBlockAtPosition(bot, 0, 0, 0).name;
+    const head = getBlockAtPosition(bot, 0, 1, 0).name;
+
+    let players = getNearbyPlayerNames(bot);
+    let bots = convoManager.getInGameAgents().filter(b => b !== agent.name);
+    players = players.filter(p => !bots.includes(p));
+
+    const helmet = bot.inventory.slots[5];
+    const chestplate = bot.inventory.slots[6];
+    const leggings = bot.inventory.slots[7];
+    const boots = bot.inventory.slots[8];
+
+    const state = {
+        name: agent.name,
+        gameplay: {
+            position,
+            dimension: bot.game.dimension,
+            gamemode: bot.game.gameMode,
+            health: Math.round(bot.health),
+            hunger: Math.round(bot.food),
+            biome: getBiomeName(bot),
+            weather,
+            timeOfDay: bot.time.timeOfDay,
+            timeLabel
+        },
+        action: {
+            current: agent.isIdle() ? 'Idle' : agent.actions.currentActionLabel,
+            isIdle: agent.isIdle()
+        },
+        surroundings: {
+            below,
+            legs,
+            head,
+            firstBlockAboveHead: getFirstBlockAboveHead(bot, null, 32)
+        },
+        inventory: {
+            counts: getInventoryCounts(bot),
+            stacksUsed: bot.inventory.items().length,
+            totalSlots: bot.inventory.slots.length,
+            equipment: {
+                helmet: helmet ? helmet.name : null,
+                chestplate: chestplate ? chestplate.name : null,
+                leggings: leggings ? leggings.name : null,
+                boots: boots ? boots.name : null,
+                mainHand: bot.heldItem ? bot.heldItem.name : null
+            }
+        },
+        nearby: {
+            humanPlayers: players,
+            botPlayers: bots,
+            entityTypes: getNearbyEntityTypes(bot).filter(t => t !== 'player' && t !== 'item'),
+        },
+        modes: {
+            summary: bot.modes.getMiniDocs()
+        }
+    };
+
+    return state;
+}

package/src/agent/library/index.js

@@ -0,0 +1,23 @@
+import * as skills from './skills.js';
+import * as world from './world.js';
+
+
+export function docHelper(functions, module_name) {
+    let docArray = [];
+    for (let skillFunc of functions) {
+        let str = skillFunc.toString();
+        if (str.includes('/**')) {
+            let docEntry = `${module_name}.${skillFunc.name}\n`;
+            docEntry += str.substring(str.indexOf('/**') + 3, str.indexOf('**/')).trim();
+            docArray.push(docEntry);
+        }
+    }
+    return docArray;
+}
+
+export function getSkillDocs() {
+    let docArray = [];
+    docArray = docArray.concat(docHelper(Object.values(skills), 'skills'));
+    docArray = docArray.concat(docHelper(Object.values(world), 'world'));
+    return docArray;
+}