open-agents-ai 0.46.0 → 0.47.0

package/README.md

@@ -333,6 +333,12 @@ Memory flows bidirectionally: the swarm reads all 5 keys at startup (Phase 0) an
 
 The Monitor agent can be "detached" between experiment rounds by the Flow Maintainer. When detached, the monitor receives a sub-task (e.g., "analyze GPU memory patterns from last 3 runs") instead of its standard watch prompt. This lets the swarm use idle monitoring capacity for useful analysis work.
 
+#### Dependency Management
+
+The autoresearch tool uses [`uv`](https://docs.astral.sh/uv/) for zero-setup Python environment management. Running `autoresearch(action="setup")` creates a `pyproject.toml` with all dependencies (torch, kernels, pyarrow, rustbpe, tiktoken, etc.) and runs `uv sync` to create a `.venv` automatically.
+
+If the Python scripts are invoked directly (without `uv run`), they self-bootstrap: detect missing packages, create a local `.venv`, install dependencies (including CUDA 12.8 torch), and re-exec with the venv's Python. This handles cases where the agent calls `python3 prepare.py` instead of `uv run prepare.py`.
+
 If no GPU is detected, the REM stage falls back to the standard multi-agent creative exploration (Visionary + Pragmatist + Cross-Pollinator + Synthesizer).
 
 ## Blessed Mode — Infinite Warm Loop
@@ -386,6 +392,23 @@ Connect the agent to a Telegram bot. Each incoming message spawns a dedicated su
 
 The bot token and admin ID are persisted to project settings, so you only need to set them once. After that, bare `/telegram` toggles the bridge on and off like a service watchdog.
 
+### Admin Slash Command Passthrough
+
+When the admin sends a `/command` in a private DM, it's routed directly through the terminal's command handler — the same code path as typing the command in the TUI. This means you can control the agent from your phone:
+
+```
+/model qwen3.5:122b     → switch model
+/voice                   → toggle TTS
+/dream                   → enter dream mode
+/listen                  → toggle voice input
+/stats                   → show session metrics
+/config                  → show current config
+/bless                   → toggle blessed mode
+/telegram status         → check bridge status
+```
+
+The command output is captured, ANSI-stripped, and sent back as a Telegram message. Skill invocations (e.g., `/ralph`, `/eval-agent`) are queued as tasks.
+
 ### Sub-Agent Architecture
 
 Each Telegram message spawns an independent `AgenticRunner` sub-agent. Sub-agent tool calls, status updates, and streaming tokens appear in the terminal waterfall view with `✈ @username` prefixes — so you can watch all Telegram conversations happening alongside your main work.

package/dist/index.js

@@ -9158,6 +9158,12 @@ Next steps:
         if (!existsSync19(join22(workspace, "train.py"))) {
           return { success: false, output: "", error: `No train.py found in ${workspace}. Run autoresearch(action="setup") first.`, durationMs: Date.now() - start };
         }
+        if (!existsSync19(join22(workspace, ".venv")) && existsSync19(join22(workspace, "pyproject.toml"))) {
+          try {
+            execSync16("uv sync 2>&1", { cwd: workspace, encoding: "utf-8", timeout: 3e5 });
+          } catch {
+          }
+        }
         const timeoutMin = Number(args["timeout_minutes"] ?? 10);
         const timeoutMs = timeoutMin * 60 * 1e3;
         const logPath = join22(workspace, "run.log");
@@ -26629,6 +26635,8 @@ with summary "no_reply" to silently skip without responding.
       onSubAgentEvent = null;
       /** Tool policy config — user overrides from config */
       toolPolicyConfig;
+      /** Command handler for admin DM slash commands (wired from interactive.ts) */
+      commandHandler = null;
       /** Media cache — fileUniqueId → cache entry */
       mediaCache = /* @__PURE__ */ new Map();
       /** Media cache directory */
@@ -26653,6 +26661,15 @@ with summary "no_reply" to silently skip without responding.
       setToolPolicyConfig(config) {
         this.toolPolicyConfig = config;
       }
+      /**
+       * Set a command handler for admin DM slash commands.
+       * When an admin sends a /command in DM, it gets routed through the TUI's
+       * handleSlashCommand instead of spawning a sub-agent.
+       * The handler receives the raw command string and returns a text result.
+       */
+      setCommandHandler(handler) {
+        this.commandHandler = handler;
+      }
       /** Register event handler for sub-agent activity (waterfall view) */
       setOnSubAgentEvent(handler) {
         this.onSubAgentEvent = handler;
@@ -26791,6 +26808,26 @@ with summary "no_reply" to silently skip without responding.
         const isAdmin = this.isAdminUser(msg);
         const toolContext = this.resolveToolContext(msg, isAdmin);
         const isAdminDM = toolContext === "telegram-admin-dm";
+        if (isAdminDM && msg.text.startsWith("/") && this.commandHandler) {
+          const cmdName = msg.text.split(/\s+/)[0].slice(1).toLowerCase();
+          if (cmdName !== "start") {
+            renderTelegramSubAgentEvent(msg.username, `command: ${msg.text}`);
+            try {
+              const result = await this.commandHandler(msg.text);
+              if (result) {
+                const html = convertMarkdownToTelegramHTML(result);
+                await this.sendMessageHTML(msg.chatId, html);
+              } else {
+                await this.sendMessage(msg.chatId, `Command executed: ${msg.text}`);
+              }
+            } catch (err) {
+              const errMsg = err instanceof Error ? err.message : String(err);
+              await this.sendMessage(msg.chatId, `Command error: ${errMsg}`).catch(() => {
+              });
+            }
+            return;
+          }
+        }
         const existing = this.subAgents.get(msg.chatId);
         if (existing && !existing.aborted) {
           existing.runner.injectUserMessage(msg.text);
@@ -29723,6 +29760,36 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           });
         }
       }
+      telegramBridge.setCommandHandler(async (input) => {
+        const captured = [];
+        const origWrite = process.stdout.write;
+        process.stdout.write = function(chunk, ...args) {
+          if (typeof chunk === "string") {
+            const clean = chunk.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "").trim();
+            if (clean)
+              captured.push(clean);
+          }
+          return origWrite.call(process.stdout, chunk, ...args);
+        };
+        try {
+          const result = await handleSlashCommand(input, commandCtx);
+          process.stdout.write = origWrite;
+          if (result === "exit") {
+            return "Exit command received (ignored via Telegram).";
+          }
+          if (result === "not_a_command") {
+            return null;
+          }
+          if (typeof result === "object" && result.type === "skill") {
+            rl.emit("line", input);
+            return `Skill invoked: ${result.name}`;
+          }
+          return captured.length > 0 ? captured.join("\n") : `Done: ${input}`;
+        } catch (err) {
+          process.stdout.write = origWrite;
+          throw err;
+        }
+      });
       await telegramBridge.start();
       writeContent(() => renderTelegramStart(telegramBridge.botUsername, adminId));
       showPrompt();

package/dist/scripts/autoresearch-prepare.py

@@ -3,7 +3,8 @@ One-time data preparation for autoresearch experiments.
 Downloads data shards and trains a BPE tokenizer.
 
 Usage:
-    python prepare.py                  # full prep (download + tokenizer)
+    uv run prepare.py                  # recommended (uses pyproject.toml deps)
+    python prepare.py                  # auto-installs missing deps into venv
     python prepare.py --num-shards 8   # download only 8 shards (for testing)
 
 Data and tokenizer are stored in ~/.cache/autoresearch/.
@@ -15,8 +16,77 @@ import time
 import math
 import argparse
 import pickle
+import subprocess
 from multiprocessing import Pool
 
+# ---------------------------------------------------------------------------
+# Auto-bootstrap: if running outside uv, ensure deps are installed
+# ---------------------------------------------------------------------------
+
+_REQUIRED_PACKAGES = {
+    "requests": "requests",
+    "pyarrow": "pyarrow",
+    "rustbpe": "rustbpe",
+    "tiktoken": "tiktoken",
+    "torch": "torch",
+}
+
+def _bootstrap_deps():
+    """Auto-install missing dependencies into a local venv if not using uv."""
+    missing = []
+    for module_name, pip_name in _REQUIRED_PACKAGES.items():
+        try:
+            __import__(module_name)
+        except ImportError:
+            missing.append(pip_name)
+
+    if not missing:
+        return  # All deps available
+
+    print(f"Missing packages: {', '.join(missing)}")
+    print("Auto-installing into local venv...")
+
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    venv_dir = os.path.join(script_dir, ".venv")
+
+    # Create venv if needed
+    if not os.path.exists(venv_dir):
+        print(f"Creating venv at {venv_dir}...")
+        subprocess.check_call([sys.executable, "-m", "venv", venv_dir])
+
+    # Determine pip path
+    pip_path = os.path.join(venv_dir, "bin", "pip")
+    if not os.path.exists(pip_path):
+        pip_path = os.path.join(venv_dir, "Scripts", "pip.exe")  # Windows
+
+    # Install missing packages
+    # For torch, use the CUDA 12.8 index if available
+    torch_pkgs = [p for p in missing if p == "torch"]
+    other_pkgs = [p for p in missing if p != "torch"]
+
+    if other_pkgs:
+        print(f"Installing: {', '.join(other_pkgs)}")
+        subprocess.check_call([pip_path, "install", "--quiet"] + other_pkgs)
+
+    if torch_pkgs:
+        print("Installing torch (CUDA 12.8)...")
+        subprocess.check_call([
+            pip_path, "install", "--quiet", "torch",
+            "--index-url", "https://download.pytorch.org/whl/cu128",
+        ])
+
+    # Re-exec with the venv's Python
+    venv_python = os.path.join(venv_dir, "bin", "python")
+    if not os.path.exists(venv_python):
+        venv_python = os.path.join(venv_dir, "Scripts", "python.exe")
+
+    print(f"Re-launching with venv Python: {venv_python}")
+    os.execv(venv_python, [venv_python] + sys.argv)
+
+# Only bootstrap if not already in a venv/uv-managed environment
+if not (hasattr(sys, "real_prefix") or (hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix)):
+    _bootstrap_deps()
+
 import requests
 import pyarrow.parquet as pq
 import rustbpe

package/dist/scripts/autoresearch-train.py

@@ -5,9 +5,40 @@ Usage: uv run train.py
 """
 
 import os
+import sys
+import subprocess
 os.environ["PYTORCH_ALLOC_CONF"] = "expandable_segments:True"
 os.environ["HF_HUB_DISABLE_PROGRESS_BARS"] = "1"
 
+# ---------------------------------------------------------------------------
+# Auto-bootstrap: ensure we're running in a venv with deps installed
+# ---------------------------------------------------------------------------
+
+def _ensure_venv():
+    """If not in a venv, check for .venv in script dir and re-exec."""
+    if hasattr(sys, "real_prefix") or (hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix):
+        return  # Already in a venv
+
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    venv_python = os.path.join(script_dir, ".venv", "bin", "python")
+
+    if os.path.exists(venv_python):
+        print(f"Re-launching with venv Python: {venv_python}")
+        os.execv(venv_python, [venv_python] + sys.argv)
+    else:
+        # Try to run prepare.py bootstrap first (it creates the venv)
+        prepare_py = os.path.join(script_dir, "prepare.py")
+        if os.path.exists(prepare_py):
+            print("No venv found. Running prepare.py to bootstrap dependencies...")
+            subprocess.check_call([sys.executable, prepare_py, "--num-shards", "0"])
+            # After prepare.py creates the venv, re-exec
+            if os.path.exists(venv_python):
+                os.execv(venv_python, [venv_python] + sys.argv)
+        print("ERROR: No venv found. Run 'uv sync' or 'python prepare.py' first.", file=sys.stderr)
+        sys.exit(1)
+
+_ensure_venv()
+
 import gc
 import math
 import time

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.46.0",
+  "version": "0.47.0",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",