@oh-my-pi/pi-coding-agent 14.9.5 → 14.9.8

package/src/eval/py/prelude.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
-# OMP IPython prelude helpers
+# OMP prelude helpers (loaded once into the runner namespace)
 if "__omp_prelude_loaded__" not in globals():
     __omp_prelude_loaded__ = True
     from pathlib import Path
     import os, json
-    from IPython.display import display as _ipy_display, JSON
+
+    # __omp_display is injected by runner.py before the prelude executes; it
+    # mirrors IPython's display() semantics with the same MIME bundle output.
+    _omp_display = __omp_display  # type: ignore[name-defined]
 
     _PRESENTABLE_REPRS = (
         "_repr_mimebundle_",
@@ -18,21 +21,22 @@ if "__omp_prelude_loaded__" not in globals():
     )
 
     def display(value):
-        """Render a value. Wraps plain dict/list values as interactive JSON."""
+        """Render a value. Falls back to a JSON+text/plain bundle for plain dict/list/tuple."""
         if any(hasattr(value, attr) for attr in _PRESENTABLE_REPRS):
-            _ipy_display(value)
+            _omp_display(value)
             return
         if isinstance(value, (dict, list, tuple)):
             try:
-                _ipy_display(JSON(value))
+                bundle = {"application/json": value, "text/plain": repr(value)}
+                _omp_display(bundle, raw=True)
                 return
             except Exception:
                 pass
-        _ipy_display(value)
+        _omp_display(value)
 
     def _emit_status(op: str, **data):
         """Emit structured status event for TUI rendering."""
-        _ipy_display({"application/x-omp-status": {"op": op, **data}}, raw=True)
+        _omp_display({"application/x-omp-status": {"op": op, **data}}, raw=True)
 
 
     def env(key: str | None = None, value: str | None = None):
@@ -372,3 +376,87 @@ if "__omp_prelude_loaded__" not in globals():
         
         return current
 
+
+    class _ToolCallable:
+        """Invokes one host-side tool via the loopback HTTP bridge."""
+
+        __slots__ = ("_proxy", "_name")
+
+        def __init__(self, proxy: "_ToolProxy", name: str):
+            self._proxy = proxy
+            self._name = name
+
+        def __repr__(self) -> str:
+            return f"<tool.{self._name}>"
+
+        def __call__(self, args=None, /, **kwargs):
+            import urllib.request, urllib.error
+            if args is None:
+                merged: dict = {}
+            elif isinstance(args, dict):
+                merged = dict(args)
+            else:
+                raise TypeError(
+                    f"tool.{self._name}(...) expects a dict of arguments (got {type(args).__name__})"
+                )
+            merged.update(kwargs)
+            if "_i" not in merged:
+                merged["_i"] = "py prelude"
+            payload = json.dumps(
+                {"session": self._proxy._session, "name": self._name, "args": merged}
+            ).encode("utf-8")
+            req = urllib.request.Request(
+                f"{self._proxy._base}/v1/tool",
+                data=payload,
+                method="POST",
+                headers={
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {self._proxy._token}",
+                },
+            )
+            try:
+                with urllib.request.urlopen(req) as resp:
+                    body = resp.read()
+            except urllib.error.HTTPError as exc:
+                body = exc.read()
+            try:
+                data = json.loads(body)
+            except json.JSONDecodeError:
+                raise RuntimeError(
+                    f"tool.{self._name}: bridge returned non-JSON response: {body[:200]!r}"
+                ) from None
+            if not isinstance(data, dict) or not data.get("ok"):
+                msg = (data or {}).get("error") if isinstance(data, dict) else None
+                raise RuntimeError(msg or f"tool.{self._name} failed")
+            return data.get("value")
+
+    class _ToolProxy:
+        """`tool.<name>(args)` proxy mirroring the JS runtime bridge."""
+
+        __slots__ = ("_base", "_token", "_session")
+
+        def __init__(self, base: str, token: str, session: str):
+            self._base = base.rstrip("/")
+            self._token = token
+            self._session = session
+
+        def __getattr__(self, name: str) -> _ToolCallable:
+            if name.startswith("_"):
+                raise AttributeError(name)
+            return _ToolCallable(self, name)
+
+        def __getitem__(self, name: str) -> _ToolCallable:
+            return _ToolCallable(self, name)
+
+        def __repr__(self) -> str:
+            return f"<tool proxy session={self._session}>"
+
+    if all(
+        _k in os.environ
+        for _k in ("PI_TOOL_BRIDGE_URL", "PI_TOOL_BRIDGE_TOKEN", "PI_TOOL_BRIDGE_SESSION")
+    ):
+        tool = _ToolProxy(
+            os.environ["PI_TOOL_BRIDGE_URL"],
+            os.environ["PI_TOOL_BRIDGE_TOKEN"],
+            os.environ["PI_TOOL_BRIDGE_SESSION"],
+        )