@melaya/runner 1.0.88 → 1.0.89

package/dist/assistantHost.py

@@ -256,15 +256,39 @@ def _build_agent():
     return agent
 
 
+_HOOKS_REGISTERED = False
+
+
 def _register_stream_hooks(agent) -> None:
-    """Emit delta / tool events live as the agent produces output (pre_print gives
-    cumulative snapshots per message; we forward the new suffix as a delta)."""
+    """Emit delta / tool events live as the agent produces output.
+
+    Registers agentscope CLASS hooks on ReActAgent — NOT instance hooks on the
+    object make_agent returned. With reliability=True (and bounded_memory) that
+    object is a WRAPPER around the real ReActAgent, so an instance hook on it
+    never fires when the inner agent runs its acting / print steps: the FE then
+    only ever saw the `round` event ("thinking…") and never the tool / delta
+    stream. Class hooks fire for the inner agent regardless of wrapping — the
+    exact mechanism the pipeline event bus uses (shared.runtime.events
+    .wire_agentscope_hooks). There's one agent per host process, so a class hook
+    is effectively instance-scoped here; it keys output to the in-flight turn via
+    _stream and no-ops between turns (turnId == "").
+
+    pre_print gives cumulative snapshots per message; we forward the new suffix
+    as a delta. post_acting gives the tool-call batch; one `tool` event each.
+    """
+    global _HOOKS_REGISTERED
+    if _HOOKS_REGISTERED:
+        return
     try:
         from shared.runtime.events import _flatten_agent_text
     except Exception:
         return
+    try:
+        from agentscope.agent import ReActAgent
+    except Exception:
+        return
 
-    def _pre_print(*_args, **kwargs) -> None:
+    def _pre_print_hook(_agent, **kwargs) -> None:
         try:
             tid = _stream.get("turnId")
             if not tid:
@@ -283,7 +307,7 @@ def _register_stream_hooks(agent) -> None:
         except Exception:
             pass
 
-    def _post_acting(*_args, **kwargs) -> None:
+    def _post_acting_hook(_agent, **kwargs) -> None:
         try:
             tid = _stream.get("turnId")
             if not tid:
@@ -295,11 +319,30 @@ def _register_stream_hooks(agent) -> None:
         except Exception:
             pass
 
-    for hook_type, fn in (("pre_print", _pre_print), ("post_acting", _post_acting)):
+    # Our agentscope's hook registration is 3-arg: (hook_type, hook_name, hook).
+    # The ORIGINAL code here called register_INSTANCE_hook(hook_type, fn) — 2 args
+    # against a 3-arg method AND on the reliability WRAPPER rather than the inner
+    # ReActAgent → TypeError, silently swallowed → the hooks were NEVER registered.
+    # That is why the FE only ever saw the `round` event ("thinking…") and none of
+    # the tool / delta stream. Register CLASS hooks with the correct arity (2-arg
+    # kept as a defensive fallback in case the signature ever changes).
+    def _reg(hook_type: str, name: str, fn) -> bool:
         try:
-            agent.register_instance_hook(hook_type, fn)
+            ReActAgent.register_class_hook(hook_type, name, fn)  # 3-arg (vendored)
+            return True
+        except TypeError:
+            try:
+                ReActAgent.register_class_hook(hook_type, fn)     # 2-arg (pip build)
+                return True
+            except Exception:
+                return False
         except Exception:
-            pass
+            return False
+
+    ok_a = _reg("pre_print", "mel_assistant_delta", _pre_print_hook)
+    ok_b = _reg("post_acting", "mel_assistant_tool", _post_acting_hook)
+    _HOOKS_REGISTERED = ok_a or ok_b
+    _log(f"stream hooks registered (delta={ok_a} tool={ok_b})")
 
 
 def _run_turn(agent, turn_id: str, message: str) -> None:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@melaya/runner",
-  "version": "1.0.88",
+  "version": "1.0.89",
   "description": "Run Melaya AI pipelines locally with your own LM Studio or Ollama models",
   "license": "UNLICENSED",
   "private": false,