@sjawhar/pi-legion-envoy 5.7.0 → 5.8.0

package/dist/envoy.js

@@ -29880,6 +29880,30 @@ function actorLabel(actor, titles) {
   }
   return `${name} (as ${serviceSubjectLabel(service)})`;
 }
+// ../contracts/src/agent-stream.ts
+var AGENT_STREAM_SUBJECT_PREFIX = "agentstream.";
+var AGENT_STREAM_PROTOCOL = 1;
+function agentStreamFramesSubject(sessionID) {
+  return `${AGENT_STREAM_SUBJECT_PREFIX}${sessionID}.frames`;
+}
+function agentStreamControlSubject(sessionID) {
+  return `${AGENT_STREAM_SUBJECT_PREFIX}${sessionID}.control`;
+}
+var AGENT_STREAM_WATCH_TTL_MS = 30000;
+var AGENT_STREAM_LIMITS = {
+  partChars: 16000,
+  toolChars: 8000,
+  historyMessages: 200,
+  historyBytes: 512 * 1024,
+  snapshotIntervalMs: 100
+};
+var AGENT_STREAM_TRUNCATION_SUFFIX = `
+\u2026 truncated`;
+function capAgentStreamText(text, limit) {
+  if (text.length <= limit)
+    return text;
+  return text.slice(0, limit) + AGENT_STREAM_TRUNCATION_SUFFIX;
+}
 // ../contracts/src/dispatch-href.ts
 function itemFromSearch(search) {
   const params = new URLSearchParams(search);
@@ -34799,6 +34823,202 @@ function sourceSession(sessionID) {
 import { logger } from "@oh-my-pi/pi-utils";
 var import_nats2 = __toESM(require_mod4(), 1);
 
+// src/agent-stream.ts
+var encoder = new TextEncoder;
+function readMessage(raw) {
+  if (typeof raw !== "object" || raw === null)
+    return null;
+  const message = raw;
+  if (typeof message.role !== "string" || typeof message.timestamp !== "number")
+    return null;
+  return {
+    host: message,
+    isError: message.isError === true,
+    role: message.role,
+    timestamp: message.timestamp,
+    toolCallId: typeof message.toolCallId === "string" ? message.toolCallId : undefined,
+    toolName: typeof message.toolName === "string" ? message.toolName : undefined
+  };
+}
+function keyFor(message) {
+  if (message.role === "toolResult") {
+    return message.toolCallId === undefined ? null : `t:${message.toolCallId}`;
+  }
+  if (message.role !== "assistant" && message.role !== "user")
+    return null;
+  return `m:${message.role === "assistant" ? "a" : "u"}${message.timestamp}`;
+}
+function contentText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  const pieces = [];
+  for (const raw of content) {
+    if (typeof raw !== "object" || raw === null)
+      continue;
+    const part = raw;
+    if (typeof part.text === "string")
+      pieces.push(part.text);
+    else if (typeof part.type === "string")
+      pieces.push(`[${part.type}]`);
+  }
+  return pieces.join(`
+`);
+}
+function boundedStrings(_key, value) {
+  return typeof value === "string" ? capAgentStreamText(value, AGENT_STREAM_LIMITS.toolChars) : value;
+}
+function renderArguments(value) {
+  if (value === undefined || value === null)
+    return "";
+  try {
+    return JSON.stringify(value, boundedStrings, 2) ?? "";
+  } catch {
+    return "[unserialisable arguments]";
+  }
+}
+function conversationParts(content) {
+  const { partChars, toolChars } = AGENT_STREAM_LIMITS;
+  if (typeof content === "string") {
+    return content === "" ? [] : [{ text: capAgentStreamText(content, partChars), type: "text" }];
+  }
+  if (!Array.isArray(content))
+    return [];
+  const parts = [];
+  for (const raw of content) {
+    if (typeof raw !== "object" || raw === null)
+      continue;
+    const part = raw;
+    if (part.type === "text" && typeof part.text === "string") {
+      parts.push({ text: capAgentStreamText(part.text, partChars), type: "text" });
+    } else if (part.type === "thinking" && typeof part.thinking === "string") {
+      parts.push({ text: capAgentStreamText(part.thinking, partChars), type: "reasoning" });
+    } else if (part.type === "toolCall" && typeof part.id === "string") {
+      parts.push({
+        argsText: capAgentStreamText(renderArguments(part.arguments), toolChars),
+        toolCallId: part.id,
+        toolName: typeof part.name === "string" ? part.name : "tool",
+        type: "tool-call"
+      });
+    } else if (typeof part.type === "string") {
+      parts.push({ text: `[${part.type}]`, type: "text" });
+    }
+  }
+  return parts;
+}
+function frameFor(entry) {
+  const { message } = entry;
+  if (message.role === "toolResult" && message.toolCallId !== undefined) {
+    return {
+      kind: "tool-result",
+      result: {
+        at: message.timestamp,
+        isError: message.isError,
+        output: capAgentStreamText(contentText(message.host.content), AGENT_STREAM_LIMITS.toolChars),
+        toolCallId: message.toolCallId,
+        toolName: message.toolName ?? "tool"
+      },
+      seq: entry.seq,
+      v: AGENT_STREAM_PROTOCOL
+    };
+  }
+  return {
+    kind: "message",
+    message: {
+      at: message.timestamp,
+      id: entry.key.slice(2),
+      parts: conversationParts(message.host.content),
+      role: message.role === "assistant" ? "assistant" : "user",
+      streaming: entry.streaming
+    },
+    seq: entry.seq,
+    v: AGENT_STREAM_PROTOCOL
+  };
+}
+
+class AgentStreamPublisher {
+  #deps;
+  #history = new Map;
+  #settled = new Set;
+  #publishedAt = new Map;
+  #seq = 0;
+  #watchedUntil = 0;
+  constructor(deps) {
+    this.#deps = deps;
+  }
+  noteViewer() {
+    this.#watchedUntil = this.#deps.now() + AGENT_STREAM_WATCH_TTL_MS;
+  }
+  get watched() {
+    return this.#deps.now() < this.#watchedUntil;
+  }
+  reset() {
+    this.#history.clear();
+    this.#settled.clear();
+    this.#publishedAt.clear();
+    this.#watchedUntil = 0;
+  }
+  record(subject2, raw, streaming) {
+    const message = readMessage(raw);
+    if (message === null)
+      return false;
+    const key = keyFor(message);
+    if (key === null)
+      return false;
+    const stillStreaming = message.role === "assistant" && streaming;
+    if (stillStreaming && this.#settled.has(key))
+      return false;
+    this.#seq += 1;
+    const entry = {
+      at: message.timestamp,
+      key,
+      message,
+      seq: this.#seq,
+      streaming: stillStreaming
+    };
+    this.#history.set(key, entry);
+    if (!stillStreaming)
+      this.#settled.add(key);
+    while (this.#history.size > AGENT_STREAM_LIMITS.historyMessages) {
+      const oldest = this.#history.keys().next();
+      if (oldest.done === true)
+        break;
+      this.#history.delete(oldest.value);
+      this.#settled.delete(oldest.value);
+      this.#publishedAt.delete(oldest.value);
+    }
+    if (!this.watched)
+      return true;
+    const now = this.#deps.now();
+    const published = this.#publishedAt.get(key);
+    const tooSoon = published !== undefined && now - published < AGENT_STREAM_LIMITS.snapshotIntervalMs;
+    if (stillStreaming && tooSoon)
+      return true;
+    this.#publishedAt.set(key, now);
+    this.#deps.publish(subject2, JSON.stringify(frameFor(entry)));
+    return true;
+  }
+  replay(sessionID) {
+    if (!this.watched)
+      return { frames: [], session_id: sessionID, v: AGENT_STREAM_PROTOCOL };
+    const ordered = [...this.#history.values()].sort((left, right) => left.at === right.at ? left.seq - right.seq : left.at - right.at);
+    let budget = AGENT_STREAM_LIMITS.historyBytes;
+    const kept = [];
+    for (let index = ordered.length - 1;index >= 0; index -= 1) {
+      const entry = ordered[index];
+      if (entry === undefined)
+        continue;
+      const frame = frameFor(entry);
+      budget -= encoder.encode(JSON.stringify(frame)).length;
+      if (budget < 0)
+        break;
+      kept.unshift(frame);
+    }
+    return { frames: kept, session_id: sessionID, v: AGENT_STREAM_PROTOCOL };
+  }
+}
+
 // src/envoy-session.ts
 import path2 from "path";
 var ENVOY_SESSIONS = Symbol.for("legion.pi-envoy.envoy-session");
@@ -35371,6 +35591,75 @@ function envoyExtension(pi) {
     }
     return true;
   };
+  const agentStream = new AgentStreamPublisher({
+    now: () => Date.now(),
+    publish: (subject2, payload) => connection?.publish(subject2, codec2.encode(payload))
+  });
+  let agentStreamControl;
+  let agentStreamControlSession = "";
+  const pumpAgentStreamControl = async (subscription, session) => {
+    try {
+      for await (const message of subscription) {
+        try {
+          const parsed = JSON.parse(codec2.decode(message.data));
+          if (typeof parsed !== "object" || parsed === null)
+            continue;
+          const request = parsed;
+          if (request.type !== "replay" && request.type !== "watch")
+            continue;
+          const reply = message.reply;
+          const answer = request.type === "replay" && reply !== undefined ? JSON.stringify(agentStream.replay(session)) : undefined;
+          agentStream.noteViewer();
+          if (answer === undefined || reply === undefined)
+            continue;
+          connection?.publish(reply, codec2.encode(answer));
+        } catch (error48) {
+          logger.warn("envoy: agent stream control message failed", {
+            error: messageFor(error48),
+            sessionID: session
+          });
+        }
+      }
+    } catch {}
+    if (agentStreamControl === subscription)
+      agentStreamControl = undefined;
+    if (shuttingDown || agentStreamControlSession !== session)
+      return;
+    setTimeout(() => {
+      if (shuttingDown || agentStreamControlSession !== session)
+        return;
+      watchAgentStream(session).catch(() => {
+        return;
+      });
+    }, RESUBSCRIBE_DELAY_MS);
+  };
+  const watchAgentStream = async (session) => {
+    if (agentStreamControlSession === session && agentStreamControl !== undefined)
+      return;
+    agentStreamControl?.unsubscribe();
+    agentStreamControl = undefined;
+    if (agentStreamControlSession !== session)
+      agentStream.reset();
+    agentStreamControlSession = session;
+    const active = await ensureConnection();
+    const subscription = active.subscribe(agentStreamControlSubject(session));
+    agentStreamControl = subscription;
+    pumpAgentStreamControl(subscription, session);
+  };
+  const recordAgentStreamMessage = (message, streaming) => {
+    if (sessionID === "")
+      return;
+    agentStream.record(agentStreamFramesSubject(sessionID), message, streaming);
+  };
+  pi.on("message_start", async (event) => {
+    recordAgentStreamMessage(event.message, true);
+  });
+  pi.on("message_update", async (event) => {
+    recordAgentStreamMessage(event.message, true);
+  });
+  pi.on("message_end", async (event) => {
+    recordAgentStreamMessage(event.message, false);
+  });
   const endRole = () => {
     claimedRoleTopic = undefined;
     claimedRoleSessionID = undefined;
@@ -35592,6 +35881,7 @@ function envoyExtension(pi) {
     }
     await ensureConnection();
     await subscribe(currentTopic);
+    await watchAgentStream(sessionID);
     if (resumed) {
       await recoverRegisteredInterests();
     }
@@ -35756,6 +36046,8 @@ function envoyExtension(pi) {
       subscriptions.clear();
       intentionallyClosed.clear();
       awaitingRetry.clear();
+      agentStreamControl = undefined;
+      agentStreamControlSession = "";
     }
   });
   for (const spec of envoyToolSpecs) {
@@ -35880,7 +36172,10 @@ function envoyExtension(pi) {
     askCheckAbort = abort;
     let answered;
     try {
-      answered = askEphemeral({ prompt: ASK_SELF_CHECK_PROMPT(open.snapshot.asks), signal: abort.signal }).then((reply) => reply.replyText, (error48) => {
+      answered = askEphemeral({
+        prompt: ASK_SELF_CHECK_PROMPT(open.snapshot.asks),
+        signal: abort.signal
+      }).then((reply) => reply.replyText, (error48) => {
         if (!abort.signal.aborted)
           logSelfCheckFailure(id, error48);
         return;

package/dist/legion.js

@@ -16192,7 +16192,7 @@ import { logger } from "@oh-my-pi/pi-utils";
 // package.json
 var package_default = {
   name: "@sjawhar/pi-legion-envoy",
-  version: "5.7.0",
+  version: "5.8.0",
   type: "module",
   omp: {
     extensions: [
@@ -30003,6 +30003,30 @@ function actorLabel(actor, titles) {
   }
   return `${name} (as ${serviceSubjectLabel(service)})`;
 }
+// ../contracts/src/agent-stream.ts
+var AGENT_STREAM_SUBJECT_PREFIX = "agentstream.";
+var AGENT_STREAM_PROTOCOL = 1;
+function agentStreamFramesSubject(sessionID) {
+  return `${AGENT_STREAM_SUBJECT_PREFIX}${sessionID}.frames`;
+}
+function agentStreamControlSubject(sessionID) {
+  return `${AGENT_STREAM_SUBJECT_PREFIX}${sessionID}.control`;
+}
+var AGENT_STREAM_WATCH_TTL_MS = 30000;
+var AGENT_STREAM_LIMITS = {
+  partChars: 16000,
+  toolChars: 8000,
+  historyMessages: 200,
+  historyBytes: 512 * 1024,
+  snapshotIntervalMs: 100
+};
+var AGENT_STREAM_TRUNCATION_SUFFIX = `
+\u2026 truncated`;
+function capAgentStreamText(text, limit) {
+  if (text.length <= limit)
+    return text;
+  return text.slice(0, limit) + AGENT_STREAM_TRUNCATION_SUFFIX;
+}
 // ../contracts/src/dispatch-href.ts
 function itemFromSearch(search) {
   const params = new URLSearchParams(search);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjawhar/pi-legion-envoy",
-  "version": "5.7.0",
+  "version": "5.8.0",
   "type": "module",
   "omp": {
     "extensions": [