Run Gemini bot as full Voyager agent

gemini_bot_stack.py

@@ -1,10 +1,11 @@
-"""Independent Gemini CLI + Mineflayer player; no Voyager checkpoint changes."""
+"""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
@@ -14,9 +15,17 @@ from typing import Any
 from voyager_stack import ROOT as VOYAGER_ROOT, SRC as VOYAGER_SRC, _wait_tcp
 
 ROOT = Path(os.environ.get("GEMINI_BOT_RUNTIME_HOME", "/tmp/gemini-bot-runtime"))
-LOG_PATH = ROOT / "bot.log"
+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-surface-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))
 
 
@@ -26,11 +35,31 @@ def _node_version() -> int:
     return int(match.group(1)) if match else 0
 
 
+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 = ""
@@ -41,60 +70,156 @@ class GeminiBotStack:
         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()):
+        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:
+        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,
+                [
+                    "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)
-        # The CLI is a planning-only model client. It cannot modify files or
-        # call terminal tools; the Mineflayer side validates each game action.
         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",
+                "google_web_search", "read_file", "read_many_files", "glob", "grep",
+                "list_directory",
             ]},
             "model": {"maxSessionTurns": 1},
             "telemetry": {"enabled": False, "logPrompts": False},
             "privacy": {"usageStatisticsEnabled": False},
         }), encoding="utf-8")
         (settings.parent / "system.md").write_text(
-            "You are the planning model for Gemini_Bot in Minecraft Creative mode. "
-            "Return only one JSON action requested by the user prompt. "
-            "Do not use tools, run commands, read files, or reveal credentials.\n",
+            "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]) -> None:
+    def _pump(self, proc: subprocess.Popen[str], path: Path, label: str) -> None:
         assert proc.stdout is not None
-        with LOG_PATH.open("a", encoding="utf-8", errors="replace") as log:
+        with path.open("a", encoding="utf-8", errors="replace") as log:
             for line in proc.stdout:
                 log.write(line)
                 log.flush()
-                print("[gemini-bot] " + line.rstrip(), flush=True)
+                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": "http://127.0.0.1:7860/v1",
+        })
+        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}"
+            )
+
+    def _start_voyager(self, env: dict[str, str]) -> None:
+        runner = Path(__file__).resolve().parent / "voyager_runner.py"
+        voyager_env = env.copy()
+        voyager_env.update({
+            "VOYAGER_HOME": str(VOYAGER_SRC),
+            "VOYAGER_OPENAI_BASE": f"http://127.0.0.1:{PROXY_PORT}/v1",
+            "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()
@@ -104,105 +229,159 @@ class GeminiBotStack:
                 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"))
+
+            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:
+            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 = {name: os.environ[name] for name in KEY_NAMES if os.environ.get(name)}
-            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_BOT_STATUS_PORT": "3001",
-            })
-            entrypoint = Path(__file__).resolve().parent / "gemini_bot.js"
+            env = self._child_env(cli, workspace)
             backoff = 5
+
             while not self.stop_event.is_set():
-                self.proc = subprocess.Popen(["node", str(entrypoint)], cwd=str(workspace), env=env,
-                                             stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
-                                             text=True, bufsize=1)
-                threading.Thread(target=self._pump, args=(self.proc,), daemon=True).start()
+                self._start_proxy(env)
+                self._start_voyager(env)
                 time.sleep(3)
-                if self.proc.poll() is None:
+                if self.proc.poll() is None and self.proxy_proc.poll() is None:
                     with self.lock:
                         self.state = "running"
                         self.error = ""
-                    rc = self.proc.wait()
-                else:
-                    rc = self.proc.returncode
+
+                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 bot exited rc={rc}; retry {self.restart_count}"
+                    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 = min(backoff * 2, 120)
+
+            _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)[:160]
-            print(f"[gemini-bot] startup error: {type(exc).__name__}: {self.error}", flush=True)
+                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-bot-bootstrap")
+            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:
-            proc = self.proc
+            runner = self.proc
+            proxy = self.proxy_proc
             self.state = "stopped"
-        if proc and proc.poll() is None:
-            proc.terminate()
-            try:
-                proc.wait(timeout=15)
-            except subprocess.TimeoutExpired:
-                proc.kill()
+        _terminate(runner)
+        _terminate(proxy)
         return self.status()
 
-    def status(self) -> dict[str, Any]:
+    def _mineflayer_status(self) -> dict[str, Any]:
         try:
-            with urllib.request.urlopen("http://127.0.0.1:3001/health", timeout=1) as response:
-                game = json.load(response)
-        except (OSError, ValueError):
-            game = {"ready": False}
+            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")
+        mineflayer = self._mineflayer_status()
+        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)
             return {
                 "state": self.state,
                 "error": self.error or None,
-                "running": bool(proc and proc.poll() is None),
-                "pid": proc.pid if proc and proc.poll() is None else 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": True,
                 "bot_username": "Gemini_Bot",
                 "model": MODEL,
                 "cli_version": CLI_VERSION,
-                "configured_key_count": sum(bool(os.environ.get(name)) for name in KEY_NAMES),
-                "game": game,
+                "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/"),
+                "activity": {
+                    "completed_count": len(completed),
+                    "failed_count": len(failed),
+                    "recent_completed": completed[-5:],
+                    "recent_failed": failed[-8:],
+                },
+                "mineflayer": mineflayer,
+                "proxy": proxy,
+                "game": mineflayer,
             }
 
 

gemini_voyager_proxy.py

@@ -0,0 +1,178 @@
+"""OpenAI-compatible local adapter backed by Gemini CLI for Voyager."""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import threading
+import time
+import urllib.request
+import uuid
+from typing import Any
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import JSONResponse, StreamingResponse
+
+MODEL = os.environ.get("GEMINI_VOYAGER_MODEL", "gemini-3.5-flash-lite")
+CLI = os.environ["GEMINI_BOT_CLI"]
+WORKSPACE = os.environ["GEMINI_BOT_WORKSPACE"]
+HOME = os.environ["GEMINI_BOT_HOME"]
+SYSTEM_MD = os.environ["GEMINI_BOT_SYSTEM_MD"]
+KEYS = [os.environ.get(f"GEMINI_BOT_KEY_{i}") for i in range(1, 7)]
+KEYS = [key for key in KEYS if key]
+EMBED_BASE = os.environ.get("GEMINI_VOYAGER_EMBED_BASE", "http://127.0.0.1:7860/v1")
+LOCK = threading.Lock()
+STATE_LOCK = threading.Lock()
+state = {"calls": 0, "failures": 0, "selected_key": 0, "last_elapsed_s": None,
+         "prompt_tokens": 0, "completion_tokens": 0, "last_error": None}
+api = FastAPI(title="Gemini Voyager Adapter", version="1.0.0")
+def _content(value: Any) -> str:
+    if isinstance(value, str):
+        return value
+    if isinstance(value, list):
+        parts = []
+        for part in value:
+            if isinstance(part, dict) and isinstance(part.get("text"), str):
+                parts.append(part["text"])
+        return "\n".join(parts)
+    return str(value or "")
+
+
+def _prompt(messages: list[dict[str, Any]]) -> str:
+    rendered = []
+    for message in messages:
+        role = str(message.get("role", "user")).upper()
+        rendered.append(f"[{role}]\n{_content(message.get('content'))}")
+    return (
+        "You are the language model inside the Voyager Minecraft agent. "
+        "Follow the supplied system and user instructions exactly. "
+        "Return only the response format requested by the final prompt; no wrapper commentary.\n\n"
+        + "\n\n".join(rendered)
+    )
+
+
+def _usage(stats: dict[str, Any]) -> tuple[int, int]:
+    prompt = completion = 0
+    models = stats.get("models") if isinstance(stats, dict) else {}
+    if isinstance(models, dict):
+        for value in models.values():
+            tokens = value.get("tokens", {}) if isinstance(value, dict) else {}
+            prompt += int(tokens.get("prompt", tokens.get("input", tokens.get("inputTokens", 0))) or 0)
+            completion += int(tokens.get("candidates", tokens.get("output", tokens.get("outputTokens", 0))) or 0)
+    if prompt == 0 and completion == 0 and isinstance(stats, dict):
+        tokens = stats.get("tokens", {}) if isinstance(stats.get("tokens"), dict) else {}
+        prompt = int(tokens.get("prompt", tokens.get("input", tokens.get("inputTokens", 0))) or 0)
+        completion = int(tokens.get("candidates", tokens.get("output", tokens.get("outputTokens", 0))) or 0)
+    return prompt, completion
+def _call_cli(prompt: str) -> tuple[str, int, int]:
+    if not KEYS:
+        raise RuntimeError("Gemini credentials unavailable")
+    with LOCK:
+        last = "Gemini CLI failed"
+        for _ in range(min(3, len(KEYS))):
+            with STATE_LOCK:
+                slot = state["selected_key"] % len(KEYS)
+                state["calls"] += 1
+            env = {
+                "PATH": os.environ.get("PATH", "/usr/bin:/bin"),
+                "HOME": HOME,
+                "GEMINI_CLI_HOME": HOME,
+                "GEMINI_CLI_TRUST_WORKSPACE": "true",
+                "GEMINI_SYSTEM_MD": SYSTEM_MD,
+                "GEMINI_TELEMETRY_ENABLED": "false",
+                "GEMINI_TELEMETRY_LOG_PROMPTS": "false",
+                "LANG": "C.UTF-8",
+                "GEMINI_API_KEY": KEYS[slot],
+            }
+            started = time.monotonic()
+            proc = subprocess.run(
+                [CLI, "--model", MODEL, "--output-format", "json", "--approval-mode", "plan",
+                 "--prompt", prompt],
+                cwd=WORKSPACE, env=env, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
+                text=True, timeout=180, check=False,
+            )
+            elapsed = round(time.monotonic() - started, 1)
+            try:
+                envelope = json.loads(proc.stdout or "{}")
+            except ValueError:
+                envelope = {}
+            if proc.returncode == 0 and isinstance(envelope.get("response"), str):
+                p_tokens, c_tokens = _usage(envelope.get("stats") or {})
+                with STATE_LOCK:
+                    state["last_elapsed_s"] = elapsed
+                    state["prompt_tokens"] += p_tokens
+                    state["completion_tokens"] += c_tokens
+                    state["last_error"] = None
+                return envelope["response"], p_tokens, c_tokens
+            code = envelope.get("error", {}).get("code") if isinstance(envelope.get("error"), dict) else None
+            last = f"Gemini CLI exit {proc.returncode}" + (f" API {code}" if code is not None else "")
+            with STATE_LOCK:
+                state["selected_key"] = (slot + 1) % len(KEYS)
+                state["failures"] += 1
+                state["last_error"] = last
+        raise RuntimeError(last)
+
+
+def _chat_payload(body: dict[str, Any]) -> dict[str, Any]:
+    answer, prompt_tokens, completion_tokens = _call_cli(_prompt(body.get("messages") or []))
+    return {
+        "id": "chatcmpl-" + uuid.uuid4().hex[:16],
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": MODEL,
+        "choices": [{"index": 0, "message": {"role": "assistant", "content": answer},
+                     "finish_reason": "stop"}],
+        "usage": {"prompt_tokens": prompt_tokens, "completion_tokens": completion_tokens,
+                  "total_tokens": prompt_tokens + completion_tokens},
+    }
+@api.get("/health")
+def health():
+    with STATE_LOCK:
+        snapshot = dict(state)
+    return {"ready": bool(KEYS), "model": MODEL, "configured_key_count": len(KEYS), **snapshot}
+
+
+@api.get("/v1/models")
+def models():
+    return {"object": "list", "data": [{"id": MODEL, "object": "model", "owned_by": "gemini-cli"}]}
+
+
+@api.post("/v1/chat/completions")
+async def chat(request: Request):
+    body = await request.json()
+    try:
+        payload = _chat_payload(body)
+    except Exception as exc:
+        raise HTTPException(status_code=503, detail=str(exc)[:160]) from None
+    if not body.get("stream"):
+        return JSONResponse(payload)
+    content = payload["choices"][0]["message"]["content"]
+    chunk = {"id": payload["id"], "object": "chat.completion.chunk", "created": payload["created"],
+             "model": MODEL, "choices": [{"index": 0, "delta": {"role": "assistant", "content": content},
+                                           "finish_reason": "stop"}]}
+    async def events():
+        yield "data: " + json.dumps(chunk, ensure_ascii=False) + "\n\n"
+        yield "data: [DONE]\n\n"
+    return StreamingResponse(events(), media_type="text/event-stream")
+@api.post("/v1/embeddings")
+async def embeddings(request: Request):
+    body = await request.body()
+    headers = {"Content-Type": "application/json"}
+    api_key = os.environ.get("API_KEY", "").strip()
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    upstream = urllib.request.Request(
+        EMBED_BASE.rstrip("/") + "/embeddings", data=body,
+        headers=headers, method="POST",
+    )
+    try:
+        with urllib.request.urlopen(upstream, timeout=120) as response:
+            return JSONResponse(json.loads(response.read().decode("utf-8")))
+    except Exception as exc:
+        raise HTTPException(status_code=503, detail=f"embedding backend unavailable: {type(exc).__name__}") from None
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(api, host="127.0.0.1", port=int(os.environ.get("GEMINI_VOYAGER_PROXY_PORT", "7863")),
+                log_level="warning")

tests/test_gemini_bot_stack.py

@@ -1,4 +1,4 @@
-"""Gemini_Bot stays separate from the persistent Voyager bot and credentials."""
+"""Gemini_Bot runs the same Voyager architecture with isolated state and credentials."""
 import ast
 import os
 from pathlib import Path
@@ -18,6 +18,9 @@ def test_isolation():
     with patch.dict(os.environ, {name: f"private-value-{i}" for i, name in enumerate(module.KEY_NAMES)}):
         status = module.GeminiBotStack().status()
         assert status["bot_username"] == "Gemini_Bot"
+        assert status["architecture"] == "Voyager"
+        assert status["same_voyager_runtime_as_naldo"] is True
+        assert "gemini-voyager" in status["checkpoint_dir"].replace("\\", "/")
         assert status["configured_key_count"] == 6
         for name in module.KEY_NAMES:
             assert name not in str(status)
@@ -25,11 +28,15 @@ def test_isolation():
 
 
 def test_no_stored_credentials():
-    for name in ["gemini_bot.js", "gemini_bot_stack.py", "gemini_bot_logic.js"]:
+    for name in ["gemini_bot.js", "gemini_bot_stack.py", "gemini_bot_logic.js", "gemini_voyager_proxy.py"]:
         source = (ROOT / name).read_text()
         assert "AIzaSy" not in source
         assert "AQ.Ab8" not in source
-    tree = ast.parse((ROOT / "gemini_bot_stack.py").read_text())
+    stack_source = (ROOT / "gemini_bot_stack.py").read_text()
+    assert "voyager_runner.py" in stack_source
+    assert "gemini_voyager_proxy.py" in stack_source
+    assert '"gemini_bot.js"' not in stack_source
+    tree = ast.parse(stack_source)
     assert tree is not None