@voybio/ace-swarm 2.4.0 → 2.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voybio/ace-swarm",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "description": "ACE Framework MCP server and CLI — single-file ACEPACK state, local-model serving, agent orchestration, and host compliance enforcement.",
   "type": "module",
   "main": "dist/index.js",
@@ -21,6 +21,7 @@
   "files": [
     "dist/**/*.js",
     "dist/**/*.d.ts",
+    "scripts/hermes_bridge_worker.py",
     "assets",
     "README.md",
     "CHANGELOG.md"

package/scripts/hermes_bridge_worker.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""ACE-owned Hermes bridge worker.
+
+The worker reads one JSON request from stdin and writes newline-delimited
+bridge events to stdout. All Hermes stdout chatter is redirected to stderr so
+ACE never has to guess whether an unframed line is assistant text or authority.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import sys
+import traceback
+from pathlib import Path
+from typing import Any
+
+
+ORIGINAL_STDOUT = sys.stdout
+
+
+def emit(event: dict[str, Any]) -> None:
+    ORIGINAL_STDOUT.write(json.dumps(event, ensure_ascii=False, separators=(",", ":")) + "\n")
+    ORIGINAL_STDOUT.flush()
+
+
+def load_request() -> dict[str, Any]:
+    raw = sys.stdin.read()
+    if not raw.strip():
+        raise ValueError("empty bridge request")
+    parsed = json.loads(raw)
+    if not isinstance(parsed, dict):
+        raise ValueError("bridge request must be a JSON object")
+    return parsed
+
+
+def provider_for_hermes(provider: str) -> str:
+    if provider in {"llama.cpp", "ollama"}:
+        return "openai"
+    return provider
+
+
+def base_url_for_hermes(provider: str, base_url: Any) -> str:
+    raw = str(base_url or "").rstrip("/")
+    if provider == "ollama" and raw and not raw.endswith("/v1"):
+        return f"{raw}/v1"
+    return raw
+
+
+def main() -> int:
+    try:
+        request = load_request()
+        hermes_root = Path(request["hermes_root"]).resolve()
+        sys.path.insert(0, str(hermes_root))
+
+        session_id = str(request["session_id"])
+        turn_id = str(request.get("turn_id") or session_id)
+        emit({"type": "session_open", "session_id": session_id, "turn_id": turn_id})
+
+        with contextlib.redirect_stdout(sys.stderr):
+            from run_agent import AIAgent  # type: ignore
+
+            def status_callback(kind: str, message: str) -> None:
+                emit({"type": "status" if kind == "lifecycle" else "status", "session_id": session_id, "turn_id": turn_id, "kind": kind, "message": str(message)})
+
+            def delta_callback(text: str) -> None:
+                emit({"type": "delta", "session_id": session_id, "turn_id": turn_id, "text": str(text)})
+
+            def reasoning_callback(text: str) -> None:
+                emit({"type": "reasoning", "session_id": session_id, "turn_id": turn_id, "text": str(text)})
+
+            def interim_callback(text: str, **kwargs: Any) -> None:
+                emit({"type": "assistant_interim", "session_id": session_id, "turn_id": turn_id, "text": str(text), **kwargs})
+
+            def thinking_callback(text: str) -> None:
+                emit({"type": "reasoning", "session_id": session_id, "turn_id": turn_id, "text": str(text)})
+
+            def tool_start_callback(tool_name: str, *args: Any, **kwargs: Any) -> None:
+                emit({"type": "tool_start", "session_id": session_id, "turn_id": turn_id, "tool": str(tool_name), "input": kwargs.get("args") or (args[0] if args else {})})
+
+            def tool_progress_callback(tool_name: str, message: str = "", *args: Any, **kwargs: Any) -> None:
+                emit({"type": "tool_progress", "session_id": session_id, "turn_id": turn_id, "tool": str(tool_name), "message": str(message), **kwargs})
+
+            def tool_complete_callback(tool_name: str, result: Any = None, *args: Any, **kwargs: Any) -> None:
+                emit({"type": "tool_complete", "session_id": session_id, "turn_id": turn_id, "tool": str(tool_name), "result": result, **kwargs})
+
+            agent = AIAgent(
+                base_url=base_url_for_hermes(str(request.get("provider") or ""), request.get("base_url")),
+                api_key=str(request.get("api_key") or "no-key-required"),
+                provider=provider_for_hermes(str(request.get("provider") or "")),
+                model=str(request.get("model") or ""),
+                max_iterations=int(request.get("max_turns") or 6),
+                enabled_toolsets=["mcp-ace_shadow"],
+                disabled_toolsets=["terminal", "filesystem", "web", "vision", "creative", "reasoning"],
+                quiet_mode=True,
+                verbose_logging=False,
+                ephemeral_system_prompt=str(request.get("system_prompt") or ""),
+                session_id=session_id,
+                platform="ace",
+                skip_context_files=True,
+                skip_memory=True,
+                status_callback=status_callback,
+                stream_delta_callback=delta_callback,
+                reasoning_callback=reasoning_callback,
+                thinking_callback=thinking_callback,
+                interim_assistant_callback=interim_callback,
+                tool_start_callback=tool_start_callback,
+                tool_progress_callback=tool_progress_callback,
+                tool_complete_callback=tool_complete_callback,
+            )
+            emit({"type": "turn_run", "session_id": session_id, "turn_id": turn_id})
+            result = agent.run_conversation(str(request.get("task") or ""), task_id=turn_id)
+
+        final = result.get("final_response") if isinstance(result, dict) else str(result)
+        emit({
+            "type": "final",
+            "session_id": session_id,
+            "turn_id": turn_id,
+            "text": final or "",
+            "completed": bool(result.get("completed", True)) if isinstance(result, dict) else True,
+            "turns": int(result.get("api_calls", 1) or 1) if isinstance(result, dict) else 1,
+        })
+        emit({"type": "session_close", "session_id": session_id, "turn_id": turn_id})
+        return 0
+    except Exception as exc:
+        emit({
+            "type": "error",
+            "message": str(exc),
+            "traceback": traceback.format_exc(limit=8),
+        })
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())