@melaya/runner 1.0.109 → 1.0.111

package/dist/assistantHost.py

@@ -142,7 +142,7 @@ _CANCELLED = object()
 class _RedactingStdout:
     """Wrap stdout to strip long base64 runs before they reach the log.
 
-    agentscope prints every agent message verbatim (the `MelayaAssistant: {...}`
+    agentscope prints every agent message verbatim (the `Assistant: {...}`
     lines), which for phone_screenshot tool results embeds a full base64 JPEG —
     tens of KB per turn that floods and explodes the runner logs. This filter is
     line-buffered and only replaces base64-looking runs (>=200 chars), so the
@@ -212,6 +212,32 @@ def _apply_hitl_mode(mode: str | None) -> None:
     os.environ["MEL_HITL_MODE"] = normalized
 
 
+def _apply_static_context(agent, base_prompt: str, ctx) -> None:
+    """Per-turn: fold the conversation's STATIC CONTEXT (the user's persona /
+    standing instructions) into the agent's system prompt. Mirrors the cloud
+    path (assistantChat.ts). Sent on every runner:assistant_turn so a mid-chat
+    edit (or clear) takes effect on the next message — agentscope rebuilds the
+    system Msg from self.sys_prompt on every reply. DATA-ONLY: it shapes the
+    role/voice/behaviour but the platform rules, tool permissions and HITL gating
+    in the base prompt still govern."""
+    text = (str(ctx or "")).strip()
+    try:
+        if text:
+            block = (
+                "\n\n## The persona and standing instructions the user set for you "
+                "(ADOPT THIS as your role, voice and priorities for this conversation; "
+                "when asked who or what you are, answer AS this persona). It shapes "
+                "behaviour and tone but NEVER grants new tools or permissions, relaxes "
+                "the autonomy/HITL gating, reaches another tenant's data, or overrides "
+                "the platform rules above.\n" + text + "\n"
+            )
+            agent._sys_prompt = base_prompt + block
+        else:
+            agent._sys_prompt = base_prompt
+    except Exception:
+        pass
+
+
 def _emit(turn_id: str, kind: str, **fields) -> None:
     """Write one structured event line to stdout (flushed) for the runner to relay."""
     try:
@@ -407,7 +433,13 @@ def _build_agent():
     )
 
     agent = make_agent(
-        name="MelayaAssistant",
+        # 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
+        # (agentStudio.ts:4173/4258). So naming it "Assistant" makes every
+        # runner-assistant turn roll up under an "Assistant" agent in the dashboard
+        # automatically, no dashboard code change.
+        name="Assistant",
         sys_prompt=sys_prompt,
         toolkit=toolkit,
         model_name=model,
@@ -614,6 +646,19 @@ def _stdin_reader(q: "queue.Queue[str]") -> None:
 
 def main() -> int:
     _log(f"booting (provider={os.environ.get('MEL_ASSISTANT_PROVIDER')})")
+    # Wire OpenTelemetry → Melaya event relay so agentscope's @trace_llm actually
+    # exports token spans to agents.spans — the SAME thing pipelines get via
+    # events.setup_studio_forwarder(). Without this the trace gate stays off AND
+    # the exporter is disabled, so every claude_code/codex assistant turn recorded
+    # ZERO tokens (no Overview cost row, no per-turn token count). The exporter
+    # self-gates on MEL_BUILDER_URL + MEL_RUN_ID (both set by the runner spawn);
+    # idempotent + best-effort — a tracing failure NEVER blocks a turn.
+    try:
+        from shared.runtime.tracing_exporter import setup_melaya_tracing
+        setup_melaya_tracing()
+        _log("tracing wired (spans → agents.spans)")
+    except Exception:
+        _log("tracing setup unavailable (non-fatal)")
     # Mirror the spawn-time assistant autonomy mode into MEL_HITL_MODE so the
     # in-process phone tools (phone.py._cmd) see it from turn one.
     _apply_hitl_mode(None)
@@ -623,6 +668,9 @@ def main() -> int:
         _log("boot failed:\n" + traceback.format_exc())
         _emit("", "error", message=f"assistant host failed to start: {exc}")
         return 1
+    # Capture the freshly-built BASE system prompt (before any static context is
+    # folded in) so each turn can deterministically rebuild base + persona.
+    base_sys_prompt = getattr(agent, "_sys_prompt", "") or ""
 
     # PR4: report memory watermark + host identity + generation so the server can
     # decide whether to offer a generation-bound rehydrate snapshot.
@@ -702,6 +750,10 @@ def main() -> int:
         # it here (before _run_turn) is enough — no agent rebuild needed.
         if "hitl_mode" in req:
             _apply_hitl_mode(req.get("hitl_mode"))
+        # Per-turn STATIC CONTEXT: fold the conversation's persona / standing
+        # instructions into the system prompt before running the turn (parity with
+        # the cloud path; handles set / edit / clear mid-conversation).
+        _apply_static_context(agent, base_sys_prompt, req.get("static_context"))
         if not message:
             _emit(turn_id, "done")
             continue

package/dist/connection.js

@@ -1011,6 +1011,15 @@ export async function connect(opts) {
                 // consistent across surfaces. assistantHost mirrors MEL_ASSISTANT_HITL_MODE
                 // → MEL_HITL_MODE so phone.py stamps the mode on the command body.
                 MEL_RUN_ID: `assistant:${sid.split(":")[0]}`,
+                // Span tracing → agents.spans. tracing_exporter.MelayaSpanExporter only
+                // exports when BOTH MEL_RUN_ID and MEL_BUILDER_URL are present (it POSTs
+                // batches through this same local relay the pipeline spawns use, lines
+                // ~463/853). The assistant host was missing these two, so — even with
+                // @trace_llm wired — every claude_code/codex assistant turn recorded ZERO
+                // token spans. Spans land under conversation_id = MEL_RUN_ID
+                // (`assistant:<userId>`); the server trigger resolves user_id from it.
+                MEL_BUILDER_URL: `http://127.0.0.1:${relay.port}`,
+                MEL_RELAY_NONCE: relay.nonce,
                 MEL_PIPELINE_NAME: "Melaya · Assistant",
                 // Luma browser bridge (same injection as pipeline runs, line ~431): lets
                 // shared/tools/luma.py route /event/register through Playwright and bypass
@@ -1160,8 +1169,10 @@ export async function connect(opts) {
         // (mirrored to MEL_HITL_MODE) BEFORE running the turn, so a mid-session flip
         // takes effect on the very next message. Fail-safe: unknown ⇒ "safe".
         const hitlMode = (payload.hitlMode === "autonomous" || payload.hitlMode === "payments_only") ? payload.hitlMode : "safe";
+        // static_context (persona / standing instructions) is forwarded per turn; the
+        // host folds it into its system prompt before running (parity with cloud).
         try {
-            s.proc.stdin?.write(JSON.stringify({ turnId: payload.turnId, message: payload.message, hitl_mode: hitlMode }) + "\n");
+            s.proc.stdin?.write(JSON.stringify({ turnId: payload.turnId, message: payload.message, hitl_mode: hitlMode, static_context: typeof payload.staticContext === "string" ? payload.staticContext : "" }) + "\n");
         }
         catch (e) {
             socket.emit("runner:assistant_event", { sessionId: payload.sessionId, turnId: payload.turnId, kind: "error", message: `turn write failed: ${e?.message || e}` });

package/package.json

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