@melaya/runner 1.1.40 → 1.1.42

package/dist/assistantHost.py

@@ -523,9 +523,26 @@ def _extract_text(result) -> str:
 def _build_agent():
     """Build the single long-lived ReActAgent for this session."""
     from shared.runtime.agent_factory import make_agent
+    try:
+        from shared.orchestration.delegation import make_delegating_agent, DelegateSpec
+        _HAS_DELEGATION = True
+    except Exception:
+        # A runner on the NEW assistantHost.py against a STALE shared bundle that
+        # predates delegation.py must NOT brick — degrade to the plain agent
+        # build (delegates ignored, model_provider mapped back to provider=).
+        _HAS_DELEGATION = False
+        DelegateSpec = None  # sentinel; only referenced when _HAS_DELEGATION is True
+
+        def make_delegating_agent(*, model_provider="", delegates=None, **_kw):  # type: ignore[misc]
+            return make_agent(provider=model_provider, **_kw)
     from shared.runtime.registry import build_toolkit
 
     provider = os.environ.get("MEL_ASSISTANT_PROVIDER", "claude_code")
+    # Weak local models orchestrate sub-agents poorly — gate delegation OFF for
+    # them (mirrors the cloud SUBAGENT_INCAPABLE_PROVIDERS). When off, delegates
+    # is None and make_delegating_agent is byte-identical to the old make_agent
+    # build (no delegate_task tool, no prompt note).
+    _delegate_capable = _HAS_DELEGATION and provider.strip().lower() not in ("ollama", "lmstudio")
     model = os.environ.get("MEL_ASSISTANT_MODEL", "") or None
     language = os.environ.get("MEL_ASSISTANT_LANGUAGE", "en")
 
@@ -774,9 +791,22 @@ def _build_agent():
         "- CHARTS: when you use the `chart` tool, the graph ONLY renders if you paste the EXACT ```chart ...``` fenced block it returns into your reply. ALWAYS output that block verbatim where you want the chart shown; NEVER say 'the chart is above/below' or describe it instead. If you made several charts, include each block; if you regenerated one, include ONLY the final good version.\n"
         "- If a question is outside the platform, answer normally without tools.\n"
         + (f"- Answer in the user's language: {language}.\n" if language and language != "en" else "")
+        # Provider-agnostic sub-agent delegation. The delegate_task tool is
+        # registered by make_delegating_agent below (only when _delegate_capable);
+        # tell the model it exists and how to use it well. Sub-agents share this
+        # same toolkit (writes hit the SAME HITL gate) and cannot delegate further.
+        # Gated on _delegate_capable so a weak-model turn's prompt is unchanged.
+        + ((
+            "- You MAY call delegate_task(\"Specialist\", \"<scoped sub-task>\") to hand a "
+            "self-contained sub-analysis to a specialist sub-agent. Use it to fan out "
+            "INDEPENDENT sub-tasks (they can run in parallel and, when useful, on a "
+            "different model), then SYNTHESISE the results yourself. Do not over-delegate, "
+            "never delegate the whole request, and remember sub-agents cannot delegate "
+            "further.\n"
+        ) if _delegate_capable else "")
     )
 
-    agent = make_agent(
+    agent = make_delegating_agent(
         # This name IS the agent identity that agentscope stamps onto the traced
         # `invoke_agent <name>` span + gen_ai.agent.name — which is EXACTLY the
         # dimension the Overview "by agent" token breakdown groups on
@@ -787,7 +817,28 @@ def _build_agent():
         sys_prompt=sys_prompt,
         toolkit=toolkit,
         model_name=model,
-        provider=provider,
+        # make_delegating_agent forwards model_provider both to make_agent (as the
+        # provider alias -> identical resolution to the old provider=) AND to the
+        # delegate factory, so a specialist defaults to the SAME provider as the
+        # lead. Pass provider here as model_provider (not provider=) so the sub-
+        # agent inherits it instead of falling back to the anthropic env default.
+        model_provider=provider,
+        # Provider-agnostic sub-agent delegation (UNCONDITIONAL — always on). The
+        # ONLY behavioural change vs the previous make_agent build is that the
+        # agent now also carries a delegate_task tool; every other kwarg below is
+        # unchanged. The Specialist shares THIS toolkit (HITL gating preserved),
+        # is built via make_agent (no delegate_task -> depth capped at 1), and can
+        # be run on a different model via MEL_ASSISTANT_DELEGATE_MODEL/PROVIDER.
+        delegates=([
+            DelegateSpec(
+                name="Specialist",
+                crew="assistant_delegate",
+                factory="make_assistant_specialist",
+                model_name=os.environ.get("MEL_ASSISTANT_DELEGATE_MODEL", "") or "",
+                model_provider=os.environ.get("MEL_ASSISTANT_DELEGATE_PROVIDER", "") or "",
+                max_iters=6,
+            ),
+        ] if _delegate_capable else None),
         # Cloud providers on the runner path (browser control turns pinned to the
         # runner even for a cloud model) get their key passed down from the server
         # as MEL_ASSISTANT_PROVIDER_API_KEY. Empty for local providers (claude_code
@@ -873,6 +924,14 @@ def _register_stream_hooks(agent) -> None:
     # the post-hook's trailing `output` arg so ONE shape works for both.
     def _pre_print_hook(_self, kw, *_rest) -> None:
         try:
+            # Sub-agents (Specialist) share this CLASS hook, but only the LEAD
+            # ("Assistant") streams to the client. A delegate's deltas / tool
+            # chips must NOT leak into the lead's answer bubble — its result comes
+            # back via the delegate_task tool result. (Specialist name is
+            # "Assistant:Specialist", so an exact-match on the lead name filters
+            # every sub-agent.)
+            if getattr(_self, "name", "") != "Assistant":
+                return
             tid = _stream.get("turnId")
             if not tid or not isinstance(kw, dict):
                 return
@@ -911,6 +970,10 @@ def _register_stream_hooks(agent) -> None:
 
     def _post_acting_hook(_self, kw, *_rest) -> None:
         try:
+            # Only the LEAD streams tool chips; a delegate's tool calls must not
+            # surface in the lead's turn (see _pre_print_hook).
+            if getattr(_self, "name", "") != "Assistant":
+                return
             tid = _stream.get("turnId")
             if not tid or not isinstance(kw, dict):
                 return
@@ -993,6 +1056,15 @@ def _run_turn(agent, turn_id: str, message: str, browser_turn: bool = False, ima
     _stream["cancel"] = False  # fresh turn — clear any stale STOP
     _stream["usedBrowser"] = False
 
+    # Reset the per-turn sub-agent delegation budget so the breadth cap is per
+    # turn, not per session. Best-effort: never let a stale/absent bundle break a
+    # turn (recursion is still capped structurally regardless of this reset).
+    try:
+        from crews.assistant_delegate.main import reset_delegation_budget
+        reset_delegation_budget()
+    except Exception:
+        pass
+
     # Browser turns carry a WALL-CLOCK budget on top of the round budget
     # (plan 0.3): the per-turn grant is short-lived and a wedged page must not
     # pin the host. Cancellation uses the same task.cancel() path as STOP.

package/dist/pythonEnv.js

@@ -204,6 +204,17 @@ const PIP_DEPS = [
     // via the anthropic/openai wheels; pinned explicitly so a future dep
     // shuffle in those SDKs can't silently break the crew risk watcher.
     "httpx",
+    // ── Database connectors + "Test via runner" (localDbProbe.py) ──────────
+    // asyncpg + PyMySQL power the PostgreSQL / MySQL tools (shared.tools.database)
+    // AND the runner-side connection probe. Without them the DB tools 401 at
+    // runtime and the "Test via runner" button returns "asyncpg/PyMySQL not
+    // installed on this runner". cryptography (also a common transitive dep) is
+    // pinned so the Snowflake key-pair JWT path in the probe always resolves.
+    // These are the runner twin of the requirements.lock entries — the runner
+    // venv installs from THIS list, not the lock, so they must be listed here too.
+    "asyncpg",
+    "PyMySQL",
+    "cryptography",
 ];
 export function venvPython() {
     return platform() === "win32"

package/package.json

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