@elizaos/plugin-minecraft 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/index.js

@@ -0,0 +1,1362 @@
+// src/index.ts
+import { logger as logger5 } from "@elizaos/core";
+import { z as z4 } from "zod";
+
+// src/services/minecraft-service.ts
+import { logger as logger3, Service } from "@elizaos/core";
+
+// src/types.ts
+import { z } from "zod";
+var minecraftWorldStateSchema = z.object({
+  connected: z.boolean(),
+  username: z.string().nullable().optional(),
+  version: z.string().nullable().optional(),
+  health: z.number().nullable().optional(),
+  food: z.number().nullable().optional(),
+  experience: z.number().nullable().optional(),
+  position: z.object({ x: z.number(), y: z.number(), z: z.number() }).nullable().optional(),
+  yaw: z.number().nullable().optional(),
+  pitch: z.number().nullable().optional(),
+  time: z.number().nullable().optional(),
+  isRaining: z.boolean().nullable().optional(),
+  inventory: z.array(z.object({
+    name: z.string(),
+    displayName: z.string(),
+    count: z.number(),
+    slot: z.number()
+  })).optional(),
+  nearbyEntities: z.array(z.object({
+    id: z.number(),
+    type: z.string(),
+    name: z.string().nullable(),
+    username: z.string().nullable(),
+    kind: z.string().nullable(),
+    position: z.object({ x: z.number(), y: z.number(), z: z.number() })
+  })).optional()
+}).passthrough();
+
+// src/services/process-manager.ts
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { logger } from "@elizaos/core";
+
+class MinecraftProcessManager {
+  serverPort;
+  process = null;
+  isRunning = false;
+  entryPath = null;
+  constructor(serverPort) {
+    this.serverPort = serverPort;
+    this.entryPath = this.findEntry();
+  }
+  findEntry() {
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
+    const possible = [
+      join(moduleDir, "../../../mineflayer-server/dist/index.js"),
+      join(moduleDir, "../../../mineflayer-server/src/index.ts"),
+      join(moduleDir, "../../../../mineflayer-server/dist/index.js"),
+      join(moduleDir, "../../../../mineflayer-server/src/index.ts")
+    ];
+    for (const p of possible) {
+      if (existsSync(p)) {
+        logger.info(`Found mineflayer-server entry at: ${p}`);
+        return p;
+      }
+    }
+    logger.error("Could not find mineflayer-server entry file");
+    logger.error(`Searched paths: ${possible.join(", ")}`);
+    return null;
+  }
+  async start() {
+    if (this.isRunning)
+      return;
+    if (!this.entryPath) {
+      throw new Error("mineflayer-server entry not found (run: bun run build:server)");
+    }
+    const env = {
+      ...process.env,
+      MC_SERVER_PORT: this.serverPort.toString(),
+      NODE_ENV: "development"
+    };
+    const entry = this.entryPath;
+    const isTypeScript = entry.endsWith(".ts");
+    return await new Promise((resolve, reject) => {
+      if (isTypeScript) {
+        const require2 = createRequire(import.meta.url);
+        const tsxPath = require2.resolve("tsx/cli", { paths: [process.cwd()] });
+        this.process = spawn("node", [tsxPath, entry], { env });
+      } else {
+        this.process = spawn("node", [entry], { env });
+      }
+      this.process.stdout?.on("data", (data) => {
+        const msg = data.toString().trim();
+        logger.debug(`[MinecraftServer] ${msg}`);
+        if (msg.includes("listening on port")) {
+          this.isRunning = true;
+          resolve();
+        }
+      });
+      this.process.stderr?.on("data", (data) => {
+        logger.error(`[MinecraftServer Error] ${data.toString()}`);
+      });
+      this.process.on("error", (err) => {
+        this.isRunning = false;
+        reject(err);
+      });
+      this.process.on("exit", (code) => {
+        logger.info(`Minecraft server process exited with code ${code ?? "unknown"}`);
+        this.isRunning = false;
+      });
+      setTimeout(() => {
+        if (!this.isRunning) {
+          reject(new Error("mineflayer-server failed to start (timeout)"));
+        }
+      }, 15000);
+    });
+  }
+  async stop() {
+    if (!this.process || !this.isRunning)
+      return;
+    await new Promise((resolve) => {
+      this.process?.on("exit", () => resolve());
+      this.process?.kill("SIGTERM");
+      setTimeout(() => {
+        if (this.isRunning && this.process) {
+          this.process.kill("SIGKILL");
+        }
+      }, 5000);
+    });
+  }
+  isServerRunning() {
+    return this.isRunning;
+  }
+  getServerUrl() {
+    return `ws://localhost:${this.serverPort}`;
+  }
+}
+
+// src/services/websocket-client.ts
+import { logger as logger2 } from "@elizaos/core";
+import WebSocket from "ws";
+import { z as z2 } from "zod";
+var jsonValueSchema = z2.lazy(() => z2.union([
+  z2.null(),
+  z2.boolean(),
+  z2.number(),
+  z2.string(),
+  z2.array(jsonValueSchema),
+  z2.record(z2.string(), jsonValueSchema)
+]));
+var responseSchema = z2.object({
+  type: z2.string(),
+  requestId: z2.string(),
+  success: z2.boolean(),
+  data: z2.record(z2.string(), jsonValueSchema).optional(),
+  error: z2.string().optional()
+});
+
+class MinecraftWebSocketClient {
+  serverUrl;
+  ws = null;
+  pending = new Map;
+  constructor(serverUrl) {
+    this.serverUrl = serverUrl;
+  }
+  async connect() {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN)
+      return;
+    await new Promise((resolve, reject) => {
+      const ws = new WebSocket(this.serverUrl);
+      this.ws = ws;
+      ws.on("open", () => resolve());
+      ws.on("error", (err) => reject(err));
+      ws.on("message", (data) => this.onMessage(data.toString("utf8")));
+      ws.on("close", () => {
+        for (const [requestId, entry] of this.pending) {
+          clearTimeout(entry.timeoutId);
+          entry.reject(new Error(`WebSocket closed while waiting for ${requestId}`));
+        }
+        this.pending.clear();
+      });
+    });
+    logger2.info(`[Minecraft] Connected to ${this.serverUrl}`);
+  }
+  disconnect() {
+    this.ws?.close();
+    this.ws = null;
+  }
+  async health() {
+    const resp = await this.sendMessage("health", undefined, {});
+    return resp.success && resp.data?.status === "ok";
+  }
+  async sendMessage(type, botId, data, timeoutMs = 30000) {
+    const ws = this.ws;
+    if (!ws || ws.readyState !== WebSocket.OPEN) {
+      throw new Error("Not connected to Mineflayer bridge server");
+    }
+    const requestId = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    const msg = {
+      type,
+      requestId,
+      ...botId ? { botId } : {},
+      ...Object.keys(data).length > 0 ? { data } : {}
+    };
+    const payload = JSON.stringify(msg);
+    const response = await new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        this.pending.delete(requestId);
+        reject(new Error(`Request timeout: ${type}`));
+      }, timeoutMs);
+      this.pending.set(requestId, { resolve, reject, timeoutId });
+      ws.send(payload, (err) => {
+        if (err) {
+          clearTimeout(timeoutId);
+          this.pending.delete(requestId);
+          reject(err);
+        }
+      });
+    });
+    if (!response.success) {
+      throw new Error(response.error ?? `Request failed: ${type}`);
+    }
+    return response;
+  }
+  onMessage(text) {
+    let parsed;
+    try {
+      const json = JSON.parse(text);
+      parsed = responseSchema.parse(json);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger2.error(`[Minecraft] Failed to parse server message: ${msg}`);
+      return;
+    }
+    const pending = this.pending.get(parsed.requestId);
+    if (!pending)
+      return;
+    clearTimeout(pending.timeoutId);
+    this.pending.delete(parsed.requestId);
+    pending.resolve(parsed);
+  }
+}
+
+// src/services/minecraft-service.ts
+var MINECRAFT_SERVICE_TYPE = "minecraft";
+
+class Session {
+  botId;
+  createdAt;
+  constructor(botId, createdAt = new Date) {
+    this.botId = botId;
+    this.createdAt = createdAt;
+  }
+}
+
+class MinecraftService extends Service {
+  static serviceType = MINECRAFT_SERVICE_TYPE;
+  capabilityDescription = "Minecraft automation service (Mineflayer bridge)";
+  session = null;
+  processManager;
+  client;
+  isInitialized = false;
+  constructor(runtime) {
+    super(runtime);
+    if (!runtime)
+      throw new Error("MinecraftService requires a runtime");
+    this.runtime = runtime;
+    const portSetting = runtime.getSetting("MC_SERVER_PORT");
+    const port = typeof portSetting === "number" ? portSetting : Number(portSetting ?? 3457);
+    const serverPort = Number.isFinite(port) ? port : 3457;
+    this.processManager = new MinecraftProcessManager(serverPort);
+    this.client = new MinecraftWebSocketClient(this.processManager.getServerUrl());
+  }
+  static async start(runtime) {
+    const service = new MinecraftService(runtime);
+    try {
+      await service.processManager.start();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger3.warn(`Failed to start Mineflayer server process: ${msg}`);
+    }
+    await service.initialize();
+    return service;
+  }
+  async initialize() {
+    if (this.isInitialized)
+      return;
+    await this.client.connect();
+    await this.waitForReady();
+    this.isInitialized = true;
+  }
+  async stop() {
+    if (this.session) {
+      try {
+        await this.destroyBot(this.session.botId);
+      } catch {}
+    }
+    this.client.disconnect();
+    await this.processManager.stop();
+    this.isInitialized = false;
+  }
+  getClient() {
+    if (!this.isInitialized) {
+      throw new Error("Minecraft service not initialized");
+    }
+    return this.client;
+  }
+  getCurrentSession() {
+    return this.session;
+  }
+  async createBot(overrides) {
+    if (!this.isInitialized) {
+      throw new Error("Minecraft service not initialized");
+    }
+    const resp = await this.client.sendMessage("createBot", undefined, overrides ?? {});
+    const botId = typeof resp.data?.botId === "string" ? resp.data.botId : null;
+    if (!botId) {
+      throw new Error("Bridge did not return botId");
+    }
+    this.session = new Session(botId);
+    return this.session;
+  }
+  async destroyBot(botId) {
+    if (!this.isInitialized)
+      return;
+    await this.client.sendMessage("destroyBot", botId, {});
+    if (this.session?.botId === botId) {
+      this.session = null;
+    }
+  }
+  async ensureBot() {
+    if (this.session)
+      return this.session;
+    return await this.createBot();
+  }
+  async chat(message) {
+    const session = await this.ensureBot();
+    await this.client.sendMessage("chat", session.botId, { message });
+  }
+  async request(type, data) {
+    const session = await this.ensureBot();
+    const resp = await this.client.sendMessage(type, session.botId, data);
+    return resp.data ?? {};
+  }
+  async getWorldState() {
+    if (!this.session) {
+      return { connected: false };
+    }
+    const resp = await this.client.sendMessage("getState", this.session.botId, {});
+    return minecraftWorldStateSchema.parse(resp.data ?? { connected: false });
+  }
+  async waitForReady(maxAttempts = 20, delayMs = 500) {
+    for (let i = 0;i < maxAttempts; i++) {
+      try {
+        if (await this.client.health())
+          return;
+      } catch {}
+      await new Promise((r) => setTimeout(r, delayMs));
+    }
+    throw new Error("Mineflayer bridge server did not become ready");
+  }
+}
+
+// src/services/waypoints-service.ts
+import { ChannelType, MemoryType, Service as Service2, stringToUuid } from "@elizaos/core";
+var WAYPOINTS_SERVICE_TYPE = "minecraft_waypoints";
+
+class WaypointsService extends Service2 {
+  static serviceType = WAYPOINTS_SERVICE_TYPE;
+  capabilityDescription = "Minecraft waypoint storage and navigation helpers";
+  waypoints = new Map;
+  waypointsRoomId;
+  waypointsWorldId;
+  constructor(runtime) {
+    super(runtime);
+    if (!runtime) {
+      throw new Error("WaypointsService requires a runtime");
+    }
+    this.runtime = runtime;
+    this.waypointsWorldId = stringToUuid("00000000-0000-0000-0000-00000000a001");
+    this.waypointsRoomId = stringToUuid(`minecraft-waypoints:${runtime.agentId}`);
+  }
+  static async start(runtime) {
+    const service = new WaypointsService(runtime);
+    await service.initialize();
+    return service;
+  }
+  async stop() {}
+  async initialize() {
+    if (this.runtime.ensureWorldExists) {
+      await this.runtime.ensureWorldExists({
+        id: this.waypointsWorldId,
+        name: "Minecraft Waypoints",
+        agentId: this.runtime.agentId,
+        messageServerId: stringToUuid("00000000-0000-0000-0000-000000000000"),
+        metadata: {
+          type: "minecraft",
+          description: "Persistent waypoint storage"
+        }
+      });
+    }
+    if (this.runtime.ensureRoomExists) {
+      await this.runtime.ensureRoomExists({
+        id: this.waypointsRoomId,
+        name: "Minecraft Waypoints",
+        worldId: this.waypointsWorldId,
+        source: "plugin-minecraft",
+        type: ChannelType.SELF,
+        metadata: {
+          type: "minecraft",
+          description: "Persistent waypoint storage"
+        }
+      });
+    }
+    if (this.runtime.ensureParticipantInRoom) {
+      await this.runtime.ensureParticipantInRoom(this.runtime.agentId, this.waypointsRoomId);
+    }
+    const memories = await this.runtime.getMemories({
+      roomId: this.waypointsRoomId,
+      count: 500,
+      tableName: "memories"
+    });
+    for (const m of memories) {
+      const md = m.metadata;
+      if (!md || md.type !== MemoryType.CUSTOM)
+        continue;
+      const cmd = md;
+      if (cmd.waypointType !== "minecraft_waypoint")
+        continue;
+      if (typeof cmd.waypointName !== "string")
+        continue;
+      if (typeof cmd.x !== "number" || typeof cmd.y !== "number" || typeof cmd.z !== "number")
+        continue;
+      const key = cmd.waypointName.trim().toLowerCase();
+      const createdAt = typeof m.createdAt === "number" ? new Date(m.createdAt) : new Date;
+      const id = m.id ?? stringToUuid(`mc-waypoint:${this.runtime.agentId}:${key}`);
+      this.waypoints.set(key, {
+        id,
+        name: cmd.waypointName,
+        x: cmd.x,
+        y: cmd.y,
+        z: cmd.z,
+        createdAt
+      });
+    }
+  }
+  waypointIdForKey(key) {
+    return stringToUuid(`mc-waypoint:${this.runtime.agentId}:${key}`);
+  }
+  buildWaypointMemory(_key, wp) {
+    const createdAt = Date.now();
+    const content = {
+      text: `Waypoint "${wp.name}" at (${wp.x}, ${wp.y}, ${wp.z})`,
+      source: "plugin-minecraft"
+    };
+    const metadata = {
+      type: MemoryType.CUSTOM,
+      scope: "private",
+      waypointType: "minecraft_waypoint",
+      waypointName: wp.name,
+      x: wp.x,
+      y: wp.y,
+      z: wp.z,
+      tags: ["minecraft", "waypoint"],
+      timestamp: createdAt
+    };
+    return {
+      id: wp.id,
+      entityId: this.runtime.agentId,
+      agentId: this.runtime.agentId,
+      roomId: this.waypointsRoomId,
+      worldId: this.waypointsWorldId,
+      createdAt,
+      content,
+      metadata,
+      unique: true
+    };
+  }
+  async setWaypoint(name, x, y, z3) {
+    const key = name.trim().toLowerCase();
+    const wp = {
+      id: this.waypointIdForKey(key),
+      name: name.trim(),
+      x,
+      y,
+      z: z3,
+      createdAt: new Date
+    };
+    this.waypoints.set(key, wp);
+    const memory = this.buildWaypointMemory(key, wp);
+    const existing = await this.runtime.getMemories({
+      roomId: this.waypointsRoomId,
+      count: 1,
+      tableName: "memories"
+    });
+    if (existing.some((m) => m.id === wp.id)) {
+      await this.runtime.updateMemory({
+        id: wp.id,
+        content: memory.content,
+        metadata: memory.metadata
+      });
+    } else {
+      await this.runtime.createMemory(memory, "memories", true);
+    }
+    return wp;
+  }
+  async deleteWaypoint(name) {
+    const key = name.trim().toLowerCase();
+    const wp = this.waypoints.get(key);
+    const deleted = this.waypoints.delete(key);
+    if (wp) {
+      await this.runtime.deleteMemory(wp.id);
+    }
+    return deleted;
+  }
+  getWaypoint(name) {
+    const key = name.trim().toLowerCase();
+    return this.waypoints.get(key) ?? null;
+  }
+  listWaypoints() {
+    return Array.from(this.waypoints.values()).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+  }
+}
+
+// src/actions/utils.ts
+import { z as z3 } from "zod";
+var vec3Schema = z3.object({ x: z3.number(), y: z3.number(), z: z3.number() });
+function extractVec3(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      const v = vec3Schema.parse(parsed);
+      return v;
+    } catch {}
+  }
+  const m = trimmed.match(/(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)/);
+  if (!m)
+    return null;
+  const x = Number(m[1]);
+  const y = Number(m[2]);
+  const z4 = Number(m[3]);
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z4))
+    return null;
+  return { x, y, z: z4 };
+}
+
+// src/actions/helpers.ts
+var MINECRAFT_ACTION_TIMEOUT_MS = 15000;
+var MAX_MINECRAFT_TEXT_LENGTH = 2000;
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function parseJsonObject(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}"))
+    return {};
+  try {
+    const parsed = JSON.parse(trimmed);
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function readParams(options) {
+  const maybe = isRecord(options) && isRecord(options.parameters) ? options.parameters : {};
+  return maybe;
+}
+function mergedInput(message, options) {
+  return {
+    ...parseJsonObject(message.content.text ?? ""),
+    ...readParams(options)
+  };
+}
+function readString(params, ...keys) {
+  for (const key of keys) {
+    const value = params[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+  }
+  return null;
+}
+function readNumber(params, ...keys) {
+  for (const key of keys) {
+    const value = params[key];
+    if (typeof value === "number" && Number.isFinite(value))
+      return value;
+    if (typeof value === "string" && value.trim()) {
+      const parsed = Number(value);
+      if (Number.isFinite(parsed))
+        return parsed;
+    }
+  }
+  return null;
+}
+function readBoolean(params, ...keys) {
+  for (const key of keys) {
+    const value = params[key];
+    if (typeof value === "boolean")
+      return value;
+    if (typeof value === "string") {
+      const normalized = value.trim().toLowerCase();
+      if (normalized === "true")
+        return true;
+      if (normalized === "false")
+        return false;
+    }
+  }
+  return null;
+}
+function parseVec3(params, text) {
+  const x = readNumber(params, "x");
+  const y = readNumber(params, "y");
+  const z4 = readNumber(params, "z");
+  if (x !== null && y !== null && z4 !== null)
+    return { x, y, z: z4 };
+  return extractVec3(text);
+}
+function isPlaceFace(value) {
+  return value === "up" || value === "down" || value === "north" || value === "south" || value === "east" || value === "west";
+}
+function callbackContent(actionName, text, source) {
+  return {
+    text,
+    actions: [actionName],
+    source: typeof source === "string" ? source : undefined
+  };
+}
+async function emit(actionName, callback, text, source, result) {
+  const content = callbackContent(actionName, text.slice(0, MAX_MINECRAFT_TEXT_LENGTH), source);
+  await callback?.(content, actionName);
+  return { text: content.text ?? text, ...result };
+}
+async function withMinecraftTimeout(promise, label) {
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => setTimeout(() => reject(new Error(`${label} timed out`)), MINECRAFT_ACTION_TIMEOUT_MS))
+  ]);
+}
+
+// src/actions/mc.ts
+var ACTION_NAME = "MC";
+var MC_OPS = [
+  "connect",
+  "disconnect",
+  "goto",
+  "stop",
+  "look",
+  "control",
+  "waypoint_goto",
+  "dig",
+  "place",
+  "chat",
+  "attack",
+  "waypoint_set",
+  "waypoint_delete"
+];
+function normalizeOp(value) {
+  if (typeof value !== "string")
+    return null;
+  const normalized = value.trim().replace(/[\s-]+/g, "_").toLowerCase();
+  switch (normalized) {
+    case "connect":
+    case "join":
+    case "mc_connect":
+      return "connect";
+    case "disconnect":
+    case "leave":
+    case "quit":
+    case "mc_disconnect":
+      return "disconnect";
+    case "goto":
+    case "go_to":
+    case "move":
+    case "walk":
+    case "pathfind":
+      return "goto";
+    case "stop":
+    case "cancel":
+      return "stop";
+    case "look":
+    case "view":
+    case "turn":
+      return "look";
+    case "control":
+    case "press":
+    case "key":
+      return "control";
+    case "waypoint_goto":
+    case "waypointgoto":
+    case "navigate":
+      return "waypoint_goto";
+    case "dig":
+    case "mine":
+    case "break":
+      return "dig";
+    case "place":
+    case "build":
+      return "place";
+    case "chat":
+    case "say":
+    case "tell":
+    case "message":
+    case "mc_chat":
+      return "chat";
+    case "attack":
+    case "hit":
+    case "mc_attack":
+      return "attack";
+    case "waypoint_set":
+    case "waypointset":
+    case "save_waypoint":
+      return "waypoint_set";
+    case "waypoint_delete":
+    case "waypointdelete":
+    case "delete_waypoint":
+      return "waypoint_delete";
+    default:
+      return MC_OPS.includes(normalized) ? normalized : null;
+  }
+}
+function parseConnectOverrides(params) {
+  const out = {};
+  const host = readString(params, "host");
+  const port = readNumber(params, "port");
+  const username = readString(params, "username");
+  const auth = readString(params, "auth");
+  const version = readString(params, "version");
+  if (host)
+    out.host = host;
+  if (port !== null && Number.isInteger(port) && port > 0)
+    out.port = port;
+  if (username)
+    out.username = username;
+  if (auth === "offline" || auth === "microsoft")
+    out.auth = auth;
+  if (version)
+    out.version = version;
+  return out;
+}
+function parseControl(params, text) {
+  const control = readString(params, "control", "key", "direction");
+  const state = readBoolean(params, "state", "pressed", "enabled");
+  const durationMs = readNumber(params, "durationMs", "duration");
+  if (control && state !== null) {
+    return durationMs && durationMs > 0 ? { control, state, durationMs } : { control, state };
+  }
+  const match = text.trim().match(/^(\S+)\s+(true|false)(?:\s+(\d+))?$/i);
+  if (!match)
+    return null;
+  const parsedDuration = match[3] ? Number(match[3]) : undefined;
+  if (parsedDuration !== undefined && !Number.isFinite(parsedDuration))
+    return null;
+  return parsedDuration ? {
+    control: match[1],
+    state: match[2].toLowerCase() === "true",
+    durationMs: parsedDuration
+  } : { control: match[1], state: match[2].toLowerCase() === "true" };
+}
+function parseLook(params, text) {
+  const yaw = readNumber(params, "yaw");
+  const pitch = readNumber(params, "pitch");
+  if (yaw !== null && pitch !== null)
+    return { yaw, pitch };
+  const match = text.trim().match(/(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)/);
+  if (!match)
+    return null;
+  const parsedYaw = Number(match[1]);
+  const parsedPitch = Number(match[2]);
+  if (!Number.isFinite(parsedYaw) || !Number.isFinite(parsedPitch))
+    return null;
+  return { yaw: parsedYaw, pitch: parsedPitch };
+}
+function parseWaypointName(text, params) {
+  const explicit = readString(params, "name", "waypointName", "waypoint", "target");
+  if (explicit)
+    return explicit;
+  const stripped = text.trim().replace(/\b(?:minecraft|mc|waypoints?|set|save|create|delete|remove|goto|go to|navigate|to)\b/gi, " ").replace(/\s+/g, " ").trim();
+  return stripped || null;
+}
+function parsePlaceFace(params, text) {
+  const explicit = readString(params, "face");
+  if (isPlaceFace(explicit))
+    return explicit;
+  const match = text.trim().match(/\b(up|down|north|south|east|west)\b/i);
+  if (!match)
+    return null;
+  const candidate = match[1].toLowerCase();
+  return isPlaceFace(candidate) ? candidate : null;
+}
+function parseEntityId(params, text) {
+  const fromParams = readNumber(params, "entityId", "entity");
+  if (fromParams !== null)
+    return fromParams;
+  const match = text.trim().match(/\b(?:entity\s*)?(\d+)\b/i);
+  if (!match)
+    return null;
+  const entityId = Number(match[1]);
+  return Number.isFinite(entityId) ? entityId : null;
+}
+var MC_SIMILES = [
+  "MC_ATTACK",
+  "MC_HIT",
+  "MC_BLOCK",
+  "MC_DIG",
+  "MC_PLACE",
+  "MC_BUILD",
+  "MC_MINE",
+  "MC_CHAT",
+  "MC_SAY",
+  "MC_MESSAGE",
+  "MC_CONNECT",
+  "MC_JOIN",
+  "MINECRAFT_CONNECT",
+  "MC_DISCONNECT",
+  "MC_LEAVE",
+  "MC_QUIT",
+  "MC_LOCOMOTE",
+  "MC_MOVE",
+  "MC_GOTO",
+  "MC_STOP",
+  "MC_LOOK",
+  "MC_CONTROL",
+  "MC_WAYPOINT",
+  "MC_WAYPOINT_SET",
+  "MC_WAYPOINT_DELETE",
+  "MC_WAYPOINT_GOTO"
+];
+var minecraftAction = {
+  name: ACTION_NAME,
+  contexts: ["connectors", "automation", "media", "messaging", "memory"],
+  contextGate: {
+    anyOf: ["connectors", "automation", "media", "messaging", "memory"]
+  },
+  roleGate: { minRole: "USER" },
+  similes: MC_SIMILES,
+  description: "Drive a Minecraft bot. Choose one action: connect (host?,port?,username?,auth?,version?), disconnect, goto (x,y,z), stop, look (yaw,pitch), control (control,state,durationMs?), waypoint_goto (name), dig (x,y,z), place (x,y,z,face), chat (message), attack (entityId), waypoint_set (name), waypoint_delete (name).",
+  descriptionCompressed: "minecraft ops: connect|disconnect|goto|stop|look|control|waypoint_*|dig|place|chat|attack",
+  parameters: [
+    {
+      name: "action",
+      description: "Operation to run.",
+      descriptionCompressed: "Action.",
+      required: true,
+      schema: { type: "string", enum: MC_OPS }
+    },
+    {
+      name: "params",
+      description: "Optional JSON object containing the fields required by the chosen op.",
+      descriptionCompressed: "Op fields.",
+      required: false,
+      schema: { type: "object" }
+    }
+  ],
+  validate: async (runtime, _message, _state) => {
+    return runtime.getService(MINECRAFT_SERVICE_TYPE) != null;
+  },
+  handler: async (runtime, message, _state, options, callback) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    if (!service)
+      return { text: "Minecraft service is not available", success: false };
+    const params = mergedInput(message, options);
+    const text = message.content.text ?? "";
+    const op = normalizeOp(params.action ?? params.subaction ?? params.op ?? params.actionType ?? params.type);
+    if (!op) {
+      return emit(ACTION_NAME, callback, `MC requires action: one of ${MC_OPS.join("|")}.`, message.content.source, { success: false });
+    }
+    try {
+      switch (op) {
+        case "connect": {
+          const session = await withMinecraftTimeout(service.createBot(parseConnectOverrides(params)), "minecraft connect");
+          return await emit(ACTION_NAME, callback, `Connected Minecraft bot (botId=${session.botId}).`, message.content.source, {
+            success: true,
+            data: { botId: session.botId },
+            values: { connected: true }
+          });
+        }
+        case "disconnect": {
+          const session = service.getCurrentSession();
+          if (!session) {
+            return emit(ACTION_NAME, callback, "No Minecraft bot is connected.", message.content.source, { success: false });
+          }
+          await withMinecraftTimeout(service.destroyBot(session.botId), "minecraft disconnect");
+          return await emit(ACTION_NAME, callback, "Disconnected Minecraft bot.", message.content.source, { success: true, values: { connected: false } });
+        }
+        case "stop": {
+          await withMinecraftTimeout(service.request("stop", {}), "minecraft stop");
+          return await emit(ACTION_NAME, callback, "Stopped movement.", message.content.source, {
+            success: true
+          });
+        }
+        case "goto": {
+          const vec = parseVec3(params, text);
+          if (!vec) {
+            return emit(ACTION_NAME, callback, "Missing coordinates (x y z).", message.content.source, { success: false });
+          }
+          await withMinecraftTimeout(service.request("goto", { x: vec.x, y: vec.y, z: vec.z }), "minecraft goto");
+          return await emit(ACTION_NAME, callback, `Moving to (${vec.x}, ${vec.y}, ${vec.z}).`, message.content.source, { success: true });
+        }
+        case "look": {
+          const req = parseLook(params, text);
+          if (!req) {
+            return emit(ACTION_NAME, callback, "Missing yaw/pitch.", message.content.source, {
+              success: false
+            });
+          }
+          await withMinecraftTimeout(service.request("look", { yaw: req.yaw, pitch: req.pitch }), "minecraft look");
+          return await emit(ACTION_NAME, callback, "Adjusted view.", message.content.source, {
+            success: true
+          });
+        }
+        case "control": {
+          const req = parseControl(params, text);
+          if (!req) {
+            return emit(ACTION_NAME, callback, "Missing control command.", message.content.source, {
+              success: false
+            });
+          }
+          await withMinecraftTimeout(service.request("control", {
+            control: req.control,
+            state: req.state,
+            ...typeof req.durationMs === "number" ? { durationMs: Math.min(req.durationMs, 1e4) } : {}
+          }), "minecraft control");
+          return await emit(ACTION_NAME, callback, `Set control ${req.control}=${String(req.state)}${req.durationMs ? ` for ${req.durationMs}ms` : ""}.`, message.content.source, { success: true });
+        }
+        case "waypoint_goto": {
+          const waypoints = runtime.getService(WAYPOINTS_SERVICE_TYPE);
+          if (!waypoints) {
+            return emit(ACTION_NAME, callback, "Waypoints service not available.", message.content.source, { success: false });
+          }
+          const name = parseWaypointName(text, params);
+          if (!name) {
+            return emit(ACTION_NAME, callback, "Missing waypoint name.", message.content.source, {
+              success: false
+            });
+          }
+          const wp = waypoints.getWaypoint(name);
+          if (!wp) {
+            return emit(ACTION_NAME, callback, `No waypoint named "${name}".`, message.content.source, { success: false });
+          }
+          await withMinecraftTimeout(service.request("goto", { x: wp.x, y: wp.y, z: wp.z }), "minecraft waypoint goto");
+          return await emit(ACTION_NAME, callback, `Navigating to waypoint "${wp.name}" at (${wp.x.toFixed(1)}, ${wp.y.toFixed(1)}, ${wp.z.toFixed(1)}).`, message.content.source, { success: true });
+        }
+        case "dig": {
+          const vec = parseVec3(params, text);
+          if (!vec) {
+            return emit(ACTION_NAME, callback, "Missing coordinates (x y z).", message.content.source, { success: false });
+          }
+          const data = await withMinecraftTimeout(service.request("dig", { x: vec.x, y: vec.y, z: vec.z }), "minecraft dig");
+          const blockName = typeof data.blockName === "string" ? data.blockName : "block";
+          return await emit(ACTION_NAME, callback, `Dug ${blockName} at (${vec.x}, ${vec.y}, ${vec.z}).`, message.content.source, { success: true, data });
+        }
+        case "place": {
+          const vec = parseVec3(params, text);
+          if (!vec) {
+            return emit(ACTION_NAME, callback, "Missing coordinates (x y z).", message.content.source, { success: false });
+          }
+          const face = parsePlaceFace(params, text);
+          if (!face) {
+            return emit(ACTION_NAME, callback, "Missing placement face (up/down/north/south/east/west).", message.content.source, { success: false });
+          }
+          await withMinecraftTimeout(service.request("place", { x: vec.x, y: vec.y, z: vec.z, face }), "minecraft place");
+          return await emit(ACTION_NAME, callback, `Placed block at (${vec.x}, ${vec.y}, ${vec.z}) face=${face}.`, message.content.source, { success: true });
+        }
+        case "chat": {
+          const msg = readString(params, "message", "text") ?? text.trim();
+          if (!msg) {
+            return emit(ACTION_NAME, callback, "No chat message provided.", message.content.source, { success: false });
+          }
+          const maxChatPreviewLength = 500;
+          await withMinecraftTimeout(service.chat(msg), "minecraft chat");
+          return await emit(ACTION_NAME, callback, `Sent Minecraft chat: ${msg.slice(0, maxChatPreviewLength)}`, message.content.source, { success: true, values: { sent: true } });
+        }
+        case "attack": {
+          const entityId = parseEntityId(params, text);
+          if (entityId === null) {
+            return emit(ACTION_NAME, callback, "Missing entityId.", message.content.source, {
+              success: false
+            });
+          }
+          await withMinecraftTimeout(service.request("attack", { entityId }), "minecraft attack");
+          return await emit(ACTION_NAME, callback, `Attacked entity ${entityId}.`, message.content.source, { success: true });
+        }
+        case "waypoint_set": {
+          const waypoints = runtime.getService(WAYPOINTS_SERVICE_TYPE);
+          if (!waypoints) {
+            return emit(ACTION_NAME, callback, "Waypoints service not available.", message.content.source, { success: false });
+          }
+          const name = parseWaypointName(text, params);
+          if (!name) {
+            return emit(ACTION_NAME, callback, "Missing waypoint name.", message.content.source, {
+              success: false
+            });
+          }
+          const worldState = await withMinecraftTimeout(service.getWorldState(), "minecraft world state");
+          const pos = worldState.position;
+          if (!pos) {
+            return emit(ACTION_NAME, callback, "No position available (is the bot connected?).", message.content.source, { success: false });
+          }
+          const wp = await waypoints.setWaypoint(name, pos.x, pos.y, pos.z);
+          return await emit(ACTION_NAME, callback, `Saved waypoint "${wp.name}" at (${wp.x.toFixed(1)}, ${wp.y.toFixed(1)}, ${wp.z.toFixed(1)}).`, message.content.source, {
+            success: true,
+            data: {
+              name: wp.name,
+              x: wp.x,
+              y: wp.y,
+              z: wp.z,
+              createdAt: wp.createdAt.toISOString()
+            }
+          });
+        }
+        case "waypoint_delete": {
+          const waypoints = runtime.getService(WAYPOINTS_SERVICE_TYPE);
+          if (!waypoints) {
+            return emit(ACTION_NAME, callback, "Waypoints service not available.", message.content.source, { success: false });
+          }
+          const name = parseWaypointName(text, params);
+          if (!name) {
+            return emit(ACTION_NAME, callback, "Missing waypoint name.", message.content.source, {
+              success: false
+            });
+          }
+          const deleted = await waypoints.deleteWaypoint(name);
+          return await emit(ACTION_NAME, callback, deleted ? `Deleted waypoint "${name}".` : `No waypoint named "${name}".`, message.content.source, { success: deleted, values: { deleted } });
+        }
+        default: {
+          const _exhaustive = op;
+          return emit(ACTION_NAME, callback, "Unknown MC op.", message.content.source, {
+            success: false
+          });
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return emit(ACTION_NAME, callback, `MC ${op} failed: ${msg}`, message.content.source, {
+        success: false,
+        data: { error: msg }
+      });
+    }
+  },
+  examples: []
+};
+// src/providers/vision.ts
+var MAX_NEARBY_ENTITIES_IN_STATE = 24;
+var MAX_NEARBY_BLOCKS_IN_STATE = 24;
+var minecraftVisionProvider = {
+  name: "MC_VISION",
+  description: "Semantic environment context: biome, what I'm looking at, key nearby blocks (logs/ores), nearby entities",
+  descriptionCompressed: "Read live Minecraft biome, looked-at block, nearby blocks, and nearby entities.",
+  dynamic: true,
+  contexts: ["automation", "agent_internal"],
+  contextGate: { anyOf: ["automation", "agent_internal"] },
+  cacheStable: false,
+  cacheScope: "turn",
+  get: async (runtime, _message, _state) => {
+    const mc = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    if (!mc) {
+      return {
+        text: "Minecraft service not available",
+        values: { connected: false },
+        data: {}
+      };
+    }
+    try {
+      const ws = await mc.getWorldState();
+      if (!ws.connected) {
+        return {
+          text: "Minecraft bot not connected",
+          values: { connected: false },
+          data: {}
+        };
+      }
+      const scan = await mc.request("scan", {
+        blocks: [
+          "oak_log",
+          "spruce_log",
+          "birch_log",
+          "jungle_log",
+          "acacia_log",
+          "dark_oak_log",
+          "stone",
+          "coal_ore",
+          "iron_ore"
+        ],
+        radius: 16,
+        maxResults: MAX_NEARBY_BLOCKS_IN_STATE
+      });
+      const blocks = Array.isArray(scan.blocks) ? scan.blocks.slice(0, MAX_NEARBY_BLOCKS_IN_STATE) : [];
+      const nearbyEntities = Array.isArray(ws.nearbyEntities) ? ws.nearbyEntities.slice(0, MAX_NEARBY_ENTITIES_IN_STATE) : [];
+      const pos = ws.position ? `(${ws.position.x.toFixed(1)}, ${ws.position.y.toFixed(1)}, ${ws.position.z.toFixed(1)})` : "(unknown)";
+      const biomeName = ws.biome && typeof ws.biome === "object" && "name" in ws.biome && typeof ws.biome.name === "string" ? ws.biome.name : null;
+      const lookingAt = ws.lookingAt;
+      const laName = lookingAt && typeof lookingAt.name === "string" ? lookingAt.name : null;
+      const laPos = lookingAt?.position ? {
+        x: typeof lookingAt.position.x === "number" ? lookingAt.position.x : null,
+        y: typeof lookingAt.position.y === "number" ? lookingAt.position.y : null,
+        z: typeof lookingAt.position.z === "number" ? lookingAt.position.z : null
+      } : null;
+      const lookingText = laName && laPos && laPos.x !== null && laPos.y !== null && laPos.z !== null ? `Looking at: ${laName} at (${laPos.x}, ${laPos.y}, ${laPos.z})` : "Looking at: (unknown)";
+      const entityCount = Array.isArray(ws.nearbyEntities) ? ws.nearbyEntities.length : 0;
+      return {
+        text: `Biome: ${biomeName ?? "unknown"}
+Position: ${pos}
+${lookingText}
+NearbyEntities: ${entityCount}
+NearbyBlocksFound: ${blocks.length}`,
+        values: {
+          connected: true,
+          biome: biomeName ?? null,
+          entityCount,
+          shownEntityCount: nearbyEntities.length,
+          blocksFound: blocks.length
+        },
+        data: {
+          biome: ws.biome ?? null,
+          position: ws.position ?? null,
+          lookingAt: ws.lookingAt ?? null,
+          nearbyEntities,
+          nearbyBlocks: blocks
+        }
+      };
+    } catch (error) {
+      return {
+        text: "Unable to load Minecraft vision context",
+        values: { connected: false, error: true },
+        data: { error: error instanceof Error ? error.message : String(error) }
+      };
+    }
+  }
+};
+// src/providers/waypoints.ts
+var MAX_WAYPOINTS_IN_STATE = 50;
+var minecraftWaypointsProvider = {
+  name: "MC_WAYPOINTS",
+  description: "Saved Minecraft waypoints (names and coordinates)",
+  descriptionCompressed: "List saved Minecraft waypoint names and coordinates.",
+  dynamic: true,
+  contexts: ["automation", "agent_internal"],
+  contextGate: { anyOf: ["automation", "agent_internal"] },
+  cacheStable: false,
+  cacheScope: "turn",
+  get: async (runtime, _message, _state) => {
+    const service = runtime.getService(WAYPOINTS_SERVICE_TYPE);
+    if (!service) {
+      return {
+        text: "Waypoints service not available",
+        values: { count: 0 },
+        data: { waypoints: [] }
+      };
+    }
+    try {
+      const list = service.listWaypoints();
+      const shown = list.slice(0, MAX_WAYPOINTS_IN_STATE);
+      const truncated = list.length > shown.length;
+      const lines = shown.map((w) => `- ${w.name}: (${w.x.toFixed(1)}, ${w.y.toFixed(1)}, ${w.z.toFixed(1)})`);
+      return {
+        text: list.length ? `Waypoints (${shown.length}/${list.length}${truncated ? ", truncated" : ""}):
+${lines.join(`
+`)}` : "No waypoints saved.",
+        values: { count: list.length, shown: shown.length, truncated },
+        data: {
+          waypoints: shown.map((w) => ({
+            name: w.name,
+            x: w.x,
+            y: w.y,
+            z: w.z,
+            createdAt: w.createdAt.toISOString()
+          }))
+        }
+      };
+    } catch (error) {
+      return {
+        text: "Unable to load Minecraft waypoints",
+        values: { count: 0, error: true },
+        data: { waypoints: [], error: error instanceof Error ? error.message : String(error) }
+      };
+    }
+  }
+};
+// src/providers/world-state.ts
+import {
+  logger as logger4
+} from "@elizaos/core";
+var MAX_INVENTORY_ROWS_IN_STATE = 36;
+var MAX_ENTITY_ROWS_IN_STATE = 24;
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function pickInventoryRows(inventory) {
+  if (!Array.isArray(inventory))
+    return [];
+  const rows = [];
+  for (const item of inventory) {
+    if (!isRecord2(item))
+      continue;
+    const slot = typeof item.slot === "number" ? item.slot : null;
+    const count = typeof item.count === "number" ? item.count : null;
+    const name = typeof item.displayName === "string" ? item.displayName : typeof item.name === "string" ? item.name : null;
+    if (slot === null || count === null || !name)
+      continue;
+    rows.push({ slot, name, count });
+  }
+  return rows;
+}
+function pickEntityRows(nearby) {
+  if (!Array.isArray(nearby))
+    return [];
+  const rows = [];
+  for (const ent of nearby) {
+    if (!isRecord2(ent))
+      continue;
+    const id = typeof ent.id === "number" ? ent.id : null;
+    const type = typeof ent.type === "string" ? ent.type : null;
+    const username = typeof ent.username === "string" ? ent.username : null;
+    const entName = typeof ent.name === "string" ? ent.name : null;
+    const name = username ?? entName ?? type ?? "unknown";
+    const pos = isRecord2(ent.position) ? ent.position : null;
+    const x = pos && typeof pos.x === "number" ? pos.x : null;
+    const y = pos && typeof pos.y === "number" ? pos.y : null;
+    const z4 = pos && typeof pos.z === "number" ? pos.z : null;
+    if (id === null || !type || x === null || y === null || z4 === null)
+      continue;
+    rows.push({
+      id,
+      type,
+      name,
+      x: Math.round(x * 10) / 10,
+      y: Math.round(y * 10) / 10,
+      z: Math.round(z4 * 10) / 10
+    });
+  }
+  return rows;
+}
+var minecraftWorldStateProvider = {
+  name: "MC_WORLD_STATE",
+  description: "Minecraft world state: connection, position, health, inventory, nearby entities",
+  descriptionCompressed: "Read live Minecraft connection, position, health, inventory, and nearby entities.",
+  dynamic: true,
+  contexts: ["automation", "agent_internal"],
+  contextGate: { anyOf: ["automation", "agent_internal"] },
+  cacheStable: false,
+  cacheScope: "turn",
+  get: async (runtime, _message, _state) => {
+    const service = runtime.getService(MINECRAFT_SERVICE_TYPE);
+    if (!service) {
+      return {
+        text: "Minecraft service is not available",
+        values: { connected: false },
+        data: {}
+      };
+    }
+    try {
+      const state = await service.getWorldState();
+      if (!state.connected) {
+        return {
+          text: "Minecraft bot is not connected. Use MC_CONNECT to join a server.",
+          values: { connected: false },
+          data: {}
+        };
+      }
+      const pos = state.position ? `(${state.position.x.toFixed(1)}, ${state.position.y.toFixed(1)}, ${state.position.z.toFixed(1)})` : "(unknown)";
+      const inventoryRows = pickInventoryRows(state.inventory).slice(0, MAX_INVENTORY_ROWS_IN_STATE);
+      const entityRows = pickEntityRows(state.nearbyEntities).slice(0, MAX_ENTITY_ROWS_IN_STATE);
+      const headerLines = [
+        `Minecraft: hp=${state.health ?? "?"} food=${state.food ?? "?"} pos=${pos} invItems=${inventoryRows.length} nearbyEntities=${entityRows.length}`
+      ];
+      if (inventoryRows.length > 0) {
+        headerLines.push(JSON.stringify({ inventory: inventoryRows }));
+      }
+      if (entityRows.length > 0) {
+        headerLines.push(JSON.stringify({ nearbyEntities: entityRows }));
+      }
+      return {
+        text: headerLines.join(`
+`),
+        values: {
+          connected: true,
+          health: state.health ?? null,
+          food: state.food ?? null,
+          x: state.position?.x ?? null,
+          y: state.position?.y ?? null,
+          z: state.position?.z ?? null,
+          inventoryCount: inventoryRows.length,
+          nearbyEntitiesCount: entityRows.length
+        },
+        data: {
+          ...state,
+          inventory: inventoryRows,
+          nearbyEntities: entityRows
+        }
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger4.error(`[Minecraft] Error getting world state: ${msg}`);
+      return {
+        text: "Error getting Minecraft world state",
+        values: { connected: false, error: true },
+        data: {}
+      };
+    }
+  }
+};
+// src/index.ts
+var configSchema = z4.object({
+  MC_SERVER_PORT: z4.string().optional().default("3457"),
+  MC_HOST: z4.string().optional().default("127.0.0.1"),
+  MC_PORT: z4.string().optional().default("25565"),
+  MC_USERNAME: z4.string().optional(),
+  MC_AUTH: z4.string().optional().default("offline"),
+  MC_VERSION: z4.string().optional()
+});
+var minecraftStateProvider = minecraftWorldStateProvider;
+var minecraftPlugin = {
+  name: "plugin-minecraft",
+  description: "Minecraft automation plugin (Mineflayer bridge)",
+  config: {
+    MC_SERVER_PORT: process.env.MC_SERVER_PORT ?? "3457",
+    MC_HOST: process.env.MC_HOST ?? "127.0.0.1",
+    MC_PORT: process.env.MC_PORT ?? "25565",
+    MC_USERNAME: process.env.MC_USERNAME ?? null,
+    MC_AUTH: process.env.MC_AUTH ?? "offline",
+    MC_VERSION: process.env.MC_VERSION ?? null
+  },
+  async init(config, _runtime) {
+    logger5.info("Initializing Minecraft plugin");
+    const validatedConfig = await configSchema.parseAsync(config);
+    for (const [key, value] of Object.entries(validatedConfig)) {
+      if (value !== undefined && value !== null) {
+        process.env[key] = String(value);
+      }
+    }
+    logger5.info("Minecraft plugin initialized");
+  },
+  services: [MinecraftService, WaypointsService],
+  actions: [minecraftAction],
+  providers: [minecraftStateProvider, minecraftWaypointsProvider, minecraftVisionProvider],
+  async dispose(runtime) {
+    await runtime.getService(WaypointsService.serviceType)?.stop();
+    await runtime.getService(MinecraftService.serviceType)?.stop();
+  }
+};
+var src_default = minecraftPlugin;
+export {
+  minecraftWorldStateSchema,
+  minecraftWorldStateProvider,
+  minecraftWaypointsProvider,
+  minecraftVisionProvider,
+  minecraftPlugin,
+  minecraftAction,
+  src_default as default,
+  WaypointsService,
+  WAYPOINTS_SERVICE_TYPE,
+  Session,
+  MinecraftWebSocketClient,
+  MinecraftService,
+  MinecraftProcessManager,
+  MINECRAFT_SERVICE_TYPE
+};
+
+//# debugId=81388854C4EA756164756E2164756E21