| """Second full Voyager agent backed by Gemini CLI, isolated from Naldo_Bot.""" |
| from __future__ import annotations |
|
|
| import json |
| import os |
| import re |
| import subprocess |
| import sys |
| import threading |
| import time |
| import urllib.request |
| from pathlib import Path |
| from typing import Any |
|
|
| from voyager_stack import ROOT as VOYAGER_ROOT, SRC as VOYAGER_SRC, CKPT_DIR as NALDO_CKPT_DIR, EMBED_BASE_URL as VOYAGER_EMBED_BASE_URL, VOYAGER, _wait_tcp, restart_backoff_after, tail_lines |
| from voyager_runtime_contract import UPSTREAM_COMMIT, read_attestation |
| from voyager_learning import read_learning_state |
|
|
| ROOT = Path(os.environ.get("GEMINI_BOT_RUNTIME_HOME", "/tmp/gemini-bot-runtime")) |
| PERSIST_ROOT = Path(os.environ.get("MINECRAFT_PERSIST_HOME", "/persist/minecraft-friends")) |
| CKPT_DIR = Path(os.environ.get( |
| "GEMINI_VOYAGER_CKPT", |
| str(PERSIST_ROOT / "gemini-voyager" / "ckpt-20260927-flat-y64-v1"), |
| )) |
| LOG_PATH = ROOT / "voyager.log" |
| PROXY_LOG_PATH = ROOT / "proxy.log" |
| CLI_VERSION = "0.61.0" |
| MODEL = "gemini-3.5-flash-lite" |
| PROXY_PORT = int(os.environ.get("GEMINI_VOYAGER_PROXY_PORT", "7863")) |
| MINEFLAYER_PORT = int(os.environ.get("GEMINI_VOYAGER_MINEFLAYER_PORT", "3001")) |
| KEY_NAMES = tuple(f"GEMINI_BOT_KEY_{i}" for i in range(1, 7)) |
|
|
|
|
| def _node_version() -> int: |
| output = subprocess.check_output(["node", "--version"], text=True, timeout=5) |
| match = re.fullmatch(r"v(\d+)\.\d+\.\d+\s*", output) |
| return int(match.group(1)) if match else 0 |
|
|
|
|
| def _wait_embedding_ready(base_url: str, timeout: float = 180.0) -> bool: |
| deadline = time.monotonic() + timeout |
| payload = json.dumps({"model": "text-embedding-ada-002", "input": "health"}).encode("utf-8") |
| while time.monotonic() < deadline: |
| request = urllib.request.Request( |
| base_url.rstrip("/") + "/embeddings", data=payload, method="POST", |
| headers={"Content-Type": "application/json"}, |
| ) |
| try: |
| remaining = max(1.0, deadline - time.monotonic()) |
| with urllib.request.urlopen(request, timeout=min(remaining, 120.0)) as response: |
| body = json.loads(response.read().decode("utf-8")) |
| if isinstance(body, dict) and body.get("data"): |
| return True |
| except Exception: |
| pass |
| time.sleep(1.0) |
| return False |
|
|
|
|
| def _terminate(proc: subprocess.Popen[str] | None, timeout: int = 15) -> None: |
| if not proc or proc.poll() is not None: |
| return |
| proc.terminate() |
| try: |
| proc.wait(timeout=timeout) |
| except subprocess.TimeoutExpired: |
| proc.kill() |
| proc.wait(timeout=5) |
|
|
|
|
| def _read_json(path: Path) -> list[str]: |
| try: |
| value = json.loads(path.read_text(encoding="utf-8")) |
| return value if isinstance(value, list) else [] |
| except (OSError, ValueError): |
| return [] |
|
|
|
|
| class GeminiBotStack: |
| def __init__(self) -> None: |
| self.lock = threading.RLock() |
| self.worker: threading.Thread | None = None |
| self.proc: subprocess.Popen[str] | None = None |
| self.proxy_proc: subprocess.Popen[str] | None = None |
| self.stop_event = threading.Event() |
| self.state = "stopped" |
| self.error = "" |
| self.started_at: float | None = None |
| self.restart_count = 0 |
|
|
| def _prepare(self) -> tuple[Path, Path]: |
| ROOT.mkdir(parents=True, exist_ok=True) |
| if _node_version() < 20: |
| raise RuntimeError("Gemini CLI 0.61.0 needs Node.js 20 or newer") |
|
|
| node_modules = VOYAGER_SRC / "voyager" / "env" / "mineflayer" / "node_modules" |
| marker = VOYAGER_ROOT / ".node-ready" |
| deadline = time.monotonic() + 900 |
| while not self.stop_event.is_set() and ( |
| not marker.exists() or not (node_modules / "mineflayer").exists() |
| ): |
| if time.monotonic() > deadline: |
| raise RuntimeError("Voyager Mineflayer dependencies did not become ready") |
| self.stop_event.wait(2) |
| if self.stop_event.is_set(): |
| raise RuntimeError("stopped") |
|
|
| cli_dir = ROOT / "cli" |
| cli = cli_dir / "node_modules" / ".bin" / "gemini" |
| version_marker = cli_dir / ".installed-version" |
| if ( |
| not cli.exists() |
| or not version_marker.exists() |
| or version_marker.read_text().strip() != CLI_VERSION |
| ): |
| cli_dir.mkdir(parents=True, exist_ok=True) |
| result = subprocess.run( |
| [ |
| "npm", "install", "--no-audit", "--no-fund", "--prefix", str(cli_dir), |
| f"@google/gemini-cli@{CLI_VERSION}", |
| ], |
| cwd=ROOT, |
| stdout=subprocess.PIPE, |
| stderr=subprocess.STDOUT, |
| text=True, |
| timeout=600, |
| check=False, |
| ) |
| if result.returncode or not cli.exists(): |
| raise RuntimeError(f"Gemini CLI install failed (rc={result.returncode})") |
| version_marker.write_text(CLI_VERSION + "\n", encoding="utf-8") |
|
|
| workspace = ROOT / "workspace" |
| settings = workspace / ".gemini" / "settings.json" |
| settings.parent.mkdir(parents=True, exist_ok=True) |
| settings.write_text(json.dumps({ |
| "general": {"enableAutoUpdate": False, "plan": {"modelRouting": False}}, |
| "tools": {"core": [], "exclude": [ |
| "run_shell_command", "write_file", "replace", "edit_file", "web_fetch", |
| "google_web_search", "read_file", "read_many_files", "glob", "grep", |
| "list_directory", |
| ]}, |
| "model": {"maxSessionTurns": 1}, |
| "modelConfigs": {"customOverrides": [{ |
| "match": {"model": MODEL}, |
| "modelConfig": {"generateContentConfig": {"temperature": 0}}, |
| }]}, |
| "telemetry": {"enabled": False, "logPrompts": False}, |
| "privacy": {"usageStatisticsEnabled": False}, |
| }), encoding="utf-8") |
| (settings.parent / "system.md").write_text( |
| "You are the language model inside the Voyager Minecraft agent. " |
| "Follow the supplied Voyager system and user prompts exactly. " |
| "Return only the format requested by the current prompt. " |
| "Do not use Gemini CLI tools, run commands, read files, or reveal credentials.\n", |
| encoding="utf-8", |
| ) |
| home = ROOT / "home" |
| home.mkdir(parents=True, exist_ok=True) |
| CKPT_DIR.mkdir(parents=True, exist_ok=True) |
| return cli, workspace |
|
|
| def _pump(self, proc: subprocess.Popen[str], path: Path, label: str) -> None: |
| assert proc.stdout is not None |
| with path.open("a", encoding="utf-8", errors="replace") as log: |
| for line in proc.stdout: |
| log.write(line) |
| log.flush() |
| print(f"[{label}] " + line.rstrip(), flush=True) |
|
|
| def _child_env(self, cli: Path, workspace: Path) -> dict[str, str]: |
| env = os.environ.copy() |
| env.update({ |
| "PATH": os.environ.get("PATH", "/usr/bin:/bin"), |
| "HOME": str(ROOT / "home"), |
| "NODE_PATH": str( |
| VOYAGER_SRC / "voyager" / "env" / "mineflayer" / "node_modules" |
| ), |
| "GEMINI_BOT_CLI": str(cli), |
| "GEMINI_BOT_WORKSPACE": str(workspace), |
| "GEMINI_BOT_HOME": str(ROOT / "home"), |
| "GEMINI_BOT_SYSTEM_MD": str(workspace / ".gemini" / "system.md"), |
| "GEMINI_VOYAGER_MODEL": MODEL, |
| "GEMINI_VOYAGER_PROXY_PORT": str(PROXY_PORT), |
| "GEMINI_VOYAGER_EMBED_BASE": VOYAGER_EMBED_BASE_URL, |
| }) |
| return env |
|
|
| def _start_proxy(self, env: dict[str, str]) -> None: |
| entrypoint = Path(__file__).resolve().parent / "gemini_voyager_proxy.py" |
| PROXY_LOG_PATH.write_text("", encoding="utf-8") |
| self.proxy_proc = subprocess.Popen( |
| [sys.executable, "-u", str(entrypoint)], |
| cwd=str(ROOT), |
| env=env, |
| stdout=subprocess.PIPE, |
| stderr=subprocess.STDOUT, |
| text=True, |
| bufsize=1, |
| ) |
| threading.Thread( |
| target=self._pump, |
| args=(self.proxy_proc, PROXY_LOG_PATH, "gemini-voyager-proxy"), |
| daemon=True, |
| ).start() |
| if not _wait_tcp("127.0.0.1", PROXY_PORT, 60): |
| raise RuntimeError("Gemini Voyager proxy did not become ready") |
| if self.proxy_proc.poll() is not None: |
| raise RuntimeError( |
| f"Gemini Voyager proxy exited rc={self.proxy_proc.returncode}" |
| ) |
| if not _wait_embedding_ready(f"http://127.0.0.1:{PROXY_PORT}/v1", timeout=180.0): |
| raise RuntimeError("Gemini embedding backend did not become ready within 180s") |
| print("[gemini-voyager] embedding probe: ready", flush=True) |
|
|
| def _start_voyager(self, env: dict[str, str]) -> None: |
| if CKPT_DIR.resolve() == NALDO_CKPT_DIR.resolve(): |
| raise RuntimeError("Gemini and Naldo must have separate Voyager checkpoints") |
| runner = Path(__file__).resolve().parent / "voyager_runner.py" |
| voyager_env = env.copy() |
| voyager_env.update({ |
| "VOYAGER_HOME": str(VOYAGER_SRC), |
| "VOYAGER_ATTESTATION_FILE": str(ROOT / "engine-attestation.json"), |
| "VOYAGER_OPENAI_BASE": f"http://127.0.0.1:{PROXY_PORT}/v1", |
| "VOYAGER_BRAIN_PROFILE": "gemini-cli", |
| "VOYAGER_API_KEY": "local-gemini-voyager", |
| "VOYAGER_MODEL": MODEL, |
| "VOYAGER_AUX_MODEL": MODEL, |
| "VOYAGER_CKPT_DIR": str(CKPT_DIR), |
| "MC_USERNAME": "Gemini_Bot", |
| "BOT_DISPLAY_NAME": "Gemini Bot", |
| "MC_PORT": "25565", |
| "MINEFLAYER_API_PORT": str(MINEFLAYER_PORT), |
| "MAX_ITERATIONS": os.environ.get( |
| "GEMINI_VOYAGER_MAX_ITERATIONS", "1000000" |
| ), |
| "OPENAI_API_REQUEST_TIMEOUT": "300", |
| "ANONYMIZED_TELEMETRY": "False", |
| "PYTHONPATH": str(VOYAGER_SRC), |
| }) |
| LOG_PATH.write_text("", encoding="utf-8") |
| self.proc = subprocess.Popen( |
| [sys.executable, "-u", str(runner)], |
| cwd=str(VOYAGER_SRC), |
| env=voyager_env, |
| stdout=subprocess.PIPE, |
| stderr=subprocess.STDOUT, |
| text=True, |
| bufsize=1, |
| ) |
| threading.Thread( |
| target=self._pump, |
| args=(self.proc, LOG_PATH, "gemini-voyager"), |
| daemon=True, |
| ).start() |
|
|
| def _boot(self) -> None: |
| self.started_at = time.time() |
| try: |
| with self.lock: |
| self.state = "waiting-minecraft" |
| self.error = "" |
| if not _wait_tcp("127.0.0.1", 25565, 240): |
| raise RuntimeError("Minecraft Java is unavailable") |
|
|
| ready_file = Path(os.environ.get( |
| "MINECRAFT_READY_FILE", "/tmp/minecraft-stack/minecraft.ready" |
| )) |
| deadline = time.monotonic() + 240 |
| while ( |
| not self.stop_event.is_set() |
| and not ready_file.exists() |
| and time.monotonic() < deadline |
| ): |
| self.stop_event.wait(1) |
| if not ready_file.exists(): |
| raise RuntimeError("Minecraft world did not finish loading") |
|
|
| if not any(os.environ.get(name) for name in KEY_NAMES): |
| with self.lock: |
| self.state = "waiting-credentials" |
| self.error = "Set GEMINI_BOT_KEY_1 as a Space secret" |
| return |
|
|
| with self.lock: |
| self.state = "preparing" |
| cli, workspace = self._prepare() |
| env = self._child_env(cli, workspace) |
| backoff = 5 |
|
|
| while not self.stop_event.is_set(): |
| run_started = time.monotonic() |
| self._start_proxy(env) |
| self._start_voyager(env) |
| time.sleep(3) |
| if self.proc.poll() is None and self.proxy_proc.poll() is None: |
| with self.lock: |
| self.state = "running" |
| self.error = "" |
|
|
| while ( |
| not self.stop_event.is_set() |
| and self.proc.poll() is None |
| and self.proxy_proc.poll() is None |
| ): |
| self.stop_event.wait(1) |
|
|
| if self.stop_event.is_set(): |
| break |
|
|
| runner_rc = self.proc.returncode if self.proc else None |
| proxy_rc = self.proxy_proc.returncode if self.proxy_proc else None |
| _terminate(self.proc) |
| _terminate(self.proxy_proc) |
| self.restart_count += 1 |
| with self.lock: |
| self.state = "restarting" |
| self.error = ( |
| f"Gemini Voyager child exit runner={runner_rc} " |
| f"proxy={proxy_rc}; retry {self.restart_count}" |
| ) |
| if self.stop_event.wait(backoff): |
| break |
| backoff = restart_backoff_after(backoff, time.monotonic() - run_started) |
|
|
| _terminate(self.proc) |
| _terminate(self.proxy_proc) |
| with self.lock: |
| self.state = "stopped" |
| except Exception as exc: |
| _terminate(self.proc) |
| _terminate(self.proxy_proc) |
| with self.lock: |
| self.state = "error" |
| self.error = str(exc)[:200] |
| print( |
| f"[gemini-voyager] startup error: {type(exc).__name__}: {self.error}", |
| flush=True, |
| ) |
|
|
| def start_async(self) -> dict[str, Any]: |
| with self.lock: |
| if self.worker and self.worker.is_alive(): |
| return self.status() |
| self.stop_event.clear() |
| self.worker = threading.Thread( |
| target=self._boot, daemon=True, name="gemini-voyager-bootstrap" |
| ) |
| self.worker.start() |
| return self.status() |
|
|
| def stop(self) -> dict[str, Any]: |
| self.stop_event.set() |
| with self.lock: |
| runner = self.proc |
| proxy = self.proxy_proc |
| self.state = "stopped" |
| _terminate(runner) |
| _terminate(proxy) |
| return self.status() |
|
|
| def _mineflayer_status(self) -> dict[str, Any]: |
| try: |
| with urllib.request.urlopen( |
| f"http://127.0.0.1:{MINEFLAYER_PORT}/health", timeout=1.5 |
| ) as response: |
| data = json.load(response) |
| return data if isinstance(data, dict) else {"ready": False} |
| except Exception: |
| return {"ready": False} |
|
|
| def _proxy_status(self) -> dict[str, Any]: |
| try: |
| with urllib.request.urlopen( |
| f"http://127.0.0.1:{PROXY_PORT}/health", timeout=1.5 |
| ) as response: |
| data = json.load(response) |
| return data if isinstance(data, dict) else {"ready": False} |
| except Exception: |
| return {"ready": False} |
|
|
| def status(self) -> dict[str, Any]: |
| completed = _read_json(CKPT_DIR / "curriculum" / "completed_tasks.json") |
| failed = _read_json(CKPT_DIR / "curriculum" / "failed_tasks.json") |
| lines = tail_lines(LOG_PATH) |
| mineflayer = self._mineflayer_status() |
| learning = read_learning_state(CKPT_DIR) |
| proxy = self._proxy_status() |
| with self.lock: |
| proc = self.proc |
| proxy_proc = self.proxy_proc |
| runner_running = bool(proc and proc.poll() is None) |
| proxy_running = bool(proxy_proc and proxy_proc.poll() is None) |
| engine = read_attestation(ROOT / "engine-attestation.json", proc.pid if runner_running else None) |
| naldo_proc = VOYAGER.proc |
| naldo_running = bool(naldo_proc and naldo_proc.poll() is None) |
| naldo_engine = read_attestation(VOYAGER_ROOT / "engine-attestation.json", naldo_proc.pid if naldo_running else None) |
| return { |
| "state": self.state, |
| "error": self.error or None, |
| "running": runner_running and proxy_running, |
| "pid": proc.pid if runner_running else None, |
| "proxy_pid": proxy_proc.pid if proxy_running else None, |
| "restart_count": self.restart_count, |
| "started_at": self.started_at, |
| "architecture": "Voyager", |
| "same_voyager_runtime_as_naldo": bool(engine and naldo_engine and engine.get("source_root") == naldo_engine.get("source_root") == str(VOYAGER_SRC.resolve()) and engine.get("upstream_commit") == naldo_engine.get("upstream_commit") == UPSTREAM_COMMIT), |
| "engine_runtime": engine, |
| "bot_username": "Gemini_Bot", |
| "model": MODEL, |
| "decision_brain": "gemini-cli-only", |
| "brain_profile": "gemini-cli", |
| "embedding_backend": VOYAGER_EMBED_BASE_URL, |
| "cli_version": CLI_VERSION, |
| "configured_key_count": sum( |
| bool(os.environ.get(name)) for name in KEY_NAMES |
| ), |
| "checkpoint_dir": str(CKPT_DIR), |
| "checkpoint_persistent": str(CKPT_DIR).startswith("/persist/"), |
| "learning": learning, |
| "activity": { |
| "completed_count": len(completed), |
| "failed_count": len(failed), |
| "recent_completed": completed[-5:], |
| "recent_failed": failed[-8:], |
| "curriculum_retry_exhausted": sum( |
| "Max retries reached, failed to propose ai task" in line for line in lines |
| ), |
| "action_model_messages": sum( |
| "****Action Agent ai message****" in line for line in lines |
| ), |
| "curriculum_model_messages": sum( |
| "****Curriculum Agent ai message****" in line for line in lines |
| ), |
| "partial_read_errors": sum("PartialReadError" in line for line in lines), |
| "file_not_found_errors": sum("FileNotFoundError" in line for line in lines), |
| "index_errors": sum("IndexError" in line for line in lines), |
| "syntax_errors": sum("SyntaxError" in line for line in lines), |
| }, |
| "mineflayer": mineflayer, |
| "proxy": proxy, |
| "game": mineflayer, |
| } |
|
|
|
|
| GEMINI_BOT = GeminiBotStack() |
|
|
