@snowyroad/arp 0.4.0 → 0.5.1

package/dist/cli.js

@@ -781,14 +781,14 @@ ${fence("peer roster", joinUntrusted(lines, "\n"))}`;
 }
 
 // src/channelContext.ts
-var MAX_INJECTED_MEMORY_CHARS = 8e3;
+var MAX_INJECTED_INSTRUCTIONS_CHARS = 8e3;
 var MAX_INJECTED_SOURCE_CHARS = 8e3;
 var MAX_INJECTED_SOURCES_TOTAL_CHARS = 24e3;
 function buildChannelContext(input) {
   let out = "";
-  if (!isBlankText(input.memory)) {
-    const raw = rawUntrusted(input.memory);
-    const bounded = raw.length > MAX_INJECTED_MEMORY_CHARS ? untrusted(raw.slice(0, MAX_INJECTED_MEMORY_CHARS) + "\n[...truncated]") : input.memory;
+  if (!isBlankText(input.instructions)) {
+    const raw = rawUntrusted(input.instructions);
+    const bounded = raw.length > MAX_INJECTED_INSTRUCTIONS_CHARS ? untrusted(raw.slice(0, MAX_INJECTED_INSTRUCTIONS_CHARS) + "\n[...truncated]") : input.instructions;
     out += `## Channel Instructions (standing guidance for this channel)
 ${fence("channel instructions", bounded)}
 ---
@@ -1387,6 +1387,14 @@ var RelayClient = class {
       activity: catchingUp ? "catching_up" : "thinking"
     });
   }
+  /** Forward one normalized agent-activity event (Agent Activity View, slice 1) to the
+   *  relay over the agent WS. The emitted frame is the normalized ActivityEvent spread
+   *  out with `type: "activity_event"` and the channelId added on top — exactly the shape
+   *  the relay ingest parses. No-op if the socket is closed (send() guards readyState),
+   *  matching sendActivity: a dropped activity event must never break a turn. */
+  sendActivityEvent(channelId, event) {
+    this.send({ type: "activity_event", channelId, ...event });
+  }
   /** Publish this agent's partial A2A card; the relay fills url/version/provider. */
   async putAgentCard(card) {
     const url = `${this.cfg.relayHttpUrl}/agents/me/agent-card`;
@@ -1440,7 +1448,7 @@ var RelayClient = class {
     if (u.thoughtTokens !== void 0) b.thoughtTokens = u.thoughtTokens;
     return b;
   }
-  async postMessage(channelId, content, usage) {
+  async postMessage(channelId, content, usage, turnId) {
     const ch = this.pathId(channelId, "channelId");
     if (!ch) return;
     const url = `${this.cfg.relayHttpUrl}/channels/${ch}/messages`;
@@ -1451,6 +1459,9 @@ var RelayClient = class {
       agentId: this.cfg.agentUuid,
       agentName: this.cfg.agentName,
       messageType: "agent",
+      // Carry the turn's id so the relay/web can correlate this message with the
+      // turn's activity events (Agent Activity View). Omit when absent.
+      ...turnId ? { turnId } : {},
       ...this.usageBody(usage)
     });
     try {
@@ -1494,21 +1505,21 @@ var RelayClient = class {
       console.warn("[arp-bridge] flow post failed:", sanitizeForTty(String(err)));
     }
   }
-  /** Channel memory text (empty if none or on error — never throws). Branded (H2-4). */
-  async fetchChannelMemory(channelId) {
+  /** Channel instructions text (empty if none or on error — never throws). Branded (H2-4). */
+  async fetchChannelInstructions(channelId) {
     const ch = this.pathId(channelId, "channelId");
     if (!ch) return untrusted("");
-    const url = `${this.cfg.relayHttpUrl}/channels/${ch}/memory`;
+    const url = `${this.cfg.relayHttpUrl}/channels/${ch}/instructions`;
     try {
       const res = await this.deps.fetchFn(url, { headers: { Authorization: `Bearer ${this.cfg.token}` } });
       if (!res.ok) {
-        console.warn("[arp-bridge] memory HTTP", res.status);
+        console.warn("[arp-bridge] instructions HTTP", res.status);
         return untrusted("");
       }
       const data = await res.json();
       return untrusted(typeof data?.content === "string" ? data.content : "");
     } catch (err) {
-      console.warn("[arp-bridge] memory fetch failed:", sanitizeForTty(String(err)));
+      console.warn("[arp-bridge] instructions fetch failed:", sanitizeForTty(String(err)));
       return untrusted("");
     }
   }
@@ -1593,18 +1604,18 @@ var RelayClient = class {
       return null;
     }
   }
-  /** Assemble the situational channel-context block (memory + sources + topics) for a
+  /** Assemble the situational channel-context block (instructions + sources + topics) for a
    *  passive message. Parallel fetch with per-source graceful degradation (each fetcher
    *  swallows its own errors). Returns "" when there is nothing to inject.
    *  The fetchers return raw structured data; untrusted-data fencing happens ONCE, in
    *  buildChannelContext (the single-layer rule, see untrusted.ts). Do not fence here. */
   async fetchChannelContext(channelId) {
-    const [memory, topics, pins] = await Promise.all([
-      this.fetchChannelMemory(channelId),
+    const [instructions, topics, pins] = await Promise.all([
+      this.fetchChannelInstructions(channelId),
       this.fetchChannelTopics(channelId),
       this.fetchSourcesContext(channelId)
     ]);
-    return buildChannelContext({ memory, topics, pins });
+    return buildChannelContext({ instructions, topics, pins });
   }
   /** Fetch a flow's transcript (used to backfill a minimal turn_notification). [] on error. */
   async fetchFlowMessages(channelId, flowId) {
@@ -1738,10 +1749,10 @@ ${toolStatusLine(this.toolMode)}
   }
   async start(opts) {
     this.session = await this.adapter.start(opts);
-    this.session.onTurn((full, usage) => {
+    this.session.onTurn((full, usage, turnId) => {
       this.beacon?.end();
       if (full.replace(/<<silent>>/gi, "").trim() === "") return;
-      this.onReply(full.replace(/^\s*(?:<<silent>>\s*)+/i, "").trim(), usage);
+      this.onReply(full.replace(/^\s*(?:<<silent>>\s*)+/i, "").trim(), usage, turnId);
     });
   }
   /**
@@ -1962,6 +1973,7 @@ function dropVendorNotifications(input) {
 }
 
 // src/acp/client.ts
+import { randomUUID as randomUUID2 } from "crypto";
 var MODEL_AUTH_ENV_KEYS = ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"];
 var BRIDGE_ENV_PREFIX = "ARP_";
 function buildAcpEnv(base, extra) {
@@ -2105,6 +2117,9 @@ var AcpClient = class {
             this.activeTurnBuffer.usage.costCurrency = u.cost.currency;
           }
         }
+        if ((u.sessionUpdate === "tool_call" || u.sessionUpdate === "tool_call_update") && this.launch.onActivity && this.activeTurnBuffer) {
+          this.emitActivity(u.sessionUpdate, u, this.activeTurnBuffer.turnId);
+        }
       },
       requestPermission: async (req) => {
         const verdict = evaluateAcpPermission(this.policy.mode, this.policy.configDirAbs, req);
@@ -2181,12 +2196,41 @@ var AcpClient = class {
     });
     return run;
   }
+  /**
+   * Normalize one ACP tool-call update (metadata only) and hand it to the activity
+   * sink, stamped with this turn's turnId. Never throws: a sink fault is caught and
+   * logged so it cannot break the turn. SLICE 1: deliberately drops content,
+   * rawInput, and rawOutput — only kind/title/status/locations are carried.
+   */
+  emitActivity(eventType, u, turnId) {
+    const sink = this.launch.onActivity;
+    if (!sink) return;
+    const locations = u.locations && u.locations.length > 0 ? u.locations.map((l) => l.line == null ? { path: l.path } : { path: l.path, line: l.line }) : null;
+    const event = {
+      turnId,
+      toolCallId: u.toolCallId,
+      eventType,
+      kind: u.kind ?? null,
+      title: u.title ?? null,
+      status: u.status ?? null,
+      locations,
+      ts: Date.now()
+    };
+    try {
+      sink(event);
+    } catch (err) {
+      console.warn(
+        `[arp-bridge] onActivity sink threw (ignored): ${sanitizeForTty(String(err?.message ?? err))}`
+      );
+    }
+  }
   /** Execute exactly one prompt turn with its own isolated reply buffer. */
   async runTurn(text) {
     if (!this.conn || !this._sessionId) {
       throw new Error("AcpClient.submit called before start()");
     }
-    const buffer = { text: "" };
+    const turnId = randomUUID2();
+    const buffer = { text: "", turnId };
     this.activeTurnBuffer = buffer;
     try {
       const resp = await this.guard(
@@ -2209,7 +2253,7 @@ var AcpClient = class {
           }
         };
       }
-      return { text: buffer.text, usage: buffer.usage };
+      return { text: buffer.text, usage: buffer.usage, turnId };
     } finally {
       if (this.activeTurnBuffer === buffer) this.activeTurnBuffer = null;
     }
@@ -2480,6 +2524,9 @@ var AcpAdapter = class {
       cwd,
       mcpServers: opts.mcpServers,
       env: { ...this.launch.env, ...opts.env },
+      // Agent Activity View: forward normalized tool-call events to the bridge-supplied
+      // sink (wired to RelayClient.sendActivityEvent). Absent => no activity surfaced.
+      onActivity: opts.onActivity,
       session: this.session ? {
         persistedId: rec?.sessionId ?? null,
         save: (id) => this.session.save(mergeSessionPointer(this.session.load(), id, cwd))
@@ -2547,7 +2594,7 @@ var AcpAdapter = class {
       const result = await client.submit(text);
       this.consecutiveRestarts = 0;
       const usage = this.usageSource?.forTurn(result.usage);
-      this.turnCbs.forEach((cb) => cb(result.text, usage));
+      this.turnCbs.forEach((cb) => cb(result.text, usage, result.turnId));
       return true;
     } catch (err) {
       if (this.stopped) {
@@ -2830,7 +2877,7 @@ import http from "http";
 import os from "os";
 import path from "path";
 import fs from "fs";
-import { randomUUID as randomUUID2, randomBytes } from "crypto";
+import { randomUUID as randomUUID3, randomBytes } from "crypto";
 var SourceBroker = class {
   constructor(channelId, reader) {
     this.channelId = channelId;
@@ -2843,7 +2890,7 @@ var SourceBroker = class {
   socketPath = "";
   async start() {
     if (this.server) throw new Error("SourceBroker already started");
-    this.socketPath = path.join(os.tmpdir(), `arp-broker-${randomUUID2()}.sock`);
+    this.socketPath = path.join(os.tmpdir(), `arp-broker-${randomUUID3()}.sock`);
     try {
       fs.unlinkSync(this.socketPath);
     } catch {
@@ -2939,7 +2986,7 @@ async function startBridge(cfg, relay, deps) {
       const beacon = new ActivityBeacon((state) => relay.sendActivity(channelId, state));
       const session = new ChannelSession(
         adapter,
-        (text, usage) => void relay.postMessage(channelId, text, usage),
+        (text, usage, turnId) => void relay.postMessage(channelId, text, usage, turnId),
         cfg.agentName,
         channelId,
         {
@@ -2962,7 +3009,11 @@ async function startBridge(cfg, relay, deps) {
         ]
       }];
       try {
-        await session.start({ model: cfg.model, mcpServers });
+        await session.start({
+          model: cfg.model,
+          mcpServers,
+          onActivity: (event) => relay.sendActivityEvent(channelId, event)
+        });
       } catch (err) {
         void broker.stop();
         throw err;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowyroad/arp",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Connect your own coding agent (Claude Code, Codex, Gemini, Grok) to an Agent Relay Protocol channel and collaborate with other agents and humans.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "SnowyRoad",