@snowyroad/arp 0.3.5 → 0.3.7

package/dist/cli.js

@@ -1439,7 +1439,27 @@ var RelayClient = class {
       return [];
     }
   }
-  async postMessage(channelId, content) {
+  /** Spread optional usage into the outbound body. Omits undefined fields so a no-usage
+   *  call produces a body byte-identical to the pre-billing shape. */
+  usageBody(u) {
+    if (!u) return {};
+    const b = { costReported: u.costReported };
+    if (u.model !== void 0) b.model = u.model;
+    if (u.provider !== void 0) b.provider = u.provider;
+    if (u.authMode !== void 0) b.authMode = u.authMode;
+    if (u.costUsed !== void 0) b.costUsed = u.costUsed;
+    if (u.costCurrency !== void 0) b.costCurrency = u.costCurrency;
+    if (u.contextUsed !== void 0) b.contextUsed = u.contextUsed;
+    if (u.contextSize !== void 0) b.contextSize = u.contextSize;
+    if (u.tokensUsed !== void 0) b.tokensUsed = u.tokensUsed;
+    if (u.inputTokens !== void 0) b.inputTokens = u.inputTokens;
+    if (u.outputTokens !== void 0) b.outputTokens = u.outputTokens;
+    if (u.cachedReadTokens !== void 0) b.cachedReadTokens = u.cachedReadTokens;
+    if (u.cachedWriteTokens !== void 0) b.cachedWriteTokens = u.cachedWriteTokens;
+    if (u.thoughtTokens !== void 0) b.thoughtTokens = u.thoughtTokens;
+    return b;
+  }
+  async postMessage(channelId, content, usage) {
     const ch = this.pathId(channelId, "channelId");
     if (!ch) return;
     const url = `${this.cfg.relayHttpUrl}/channels/${ch}/messages`;
@@ -1449,7 +1469,8 @@ var RelayClient = class {
       content,
       agentId: this.cfg.agentUuid,
       agentName: this.cfg.agentName,
-      messageType: "agent"
+      messageType: "agent",
+      ...this.usageBody(usage)
     });
     try {
       const res = await this.deps.fetchFn(url, {
@@ -1467,7 +1488,7 @@ var RelayClient = class {
   /** Post a bounded-flow reply (turn or synthesis) to the flow-scoped endpoint.
    *  agentId MUST be the agent NAME — the relay's flow gate resolves turn ownership and
    *  synthesis role via resolveAgentUUID (a name lookup); a UUID resolves to uuid.Nil -> 403. */
-  async postFlowMessage(channelId, flowId, content) {
+  async postFlowMessage(channelId, flowId, content, usage) {
     const ch = this.pathId(channelId, "channelId");
     const fl = this.pathId(flowId, "flowId");
     if (!ch || !fl) return;
@@ -1478,7 +1499,8 @@ var RelayClient = class {
       // The relay's flow gate resolves turn ownership + synthesis role by NAME
       // (resolveAgentUUID is a name lookup), so the flow reply must carry the agent name.
       agentId: this.cfg.agentName,
-      agentName: this.cfg.agentName
+      agentName: this.cfg.agentName,
+      ...this.usageBody(usage)
     });
     try {
       const res = await this.deps.fetchFn(url, {
@@ -1697,10 +1719,10 @@ ${toolStatusLine(this.toolMode)}
   }
   async start(opts) {
     this.session = await this.adapter.start(opts);
-    this.session.onTurn((full) => {
+    this.session.onTurn((full, usage) => {
       this.beacon?.end();
       if (full.replace(/<<silent>>/gi, "").trim() === "") return;
-      this.onReply(full.replace(/^\s*(?:<<silent>>\s*)+/i, "").trim());
+      this.onReply(full.replace(/^\s*(?:<<silent>>\s*)+/i, "").trim(), usage);
     });
   }
   /**
@@ -1867,7 +1889,7 @@ var ActivityBeacon = class {
 // src/adapter.ts
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { accessSync, constants, existsSync as existsSync2, statSync } from "fs";
-import { delimiter, dirname as dirname2, join as join3, resolve as resolve2 } from "path";
+import { delimiter, dirname as dirname3, join as join4, resolve as resolve2 } from "path";
 
 // src/acp/client.ts
 import { spawn } from "child_process";
@@ -1967,6 +1989,7 @@ var AcpClient = class {
   child = null;
   conn = null;
   _sessionId = null;
+  loadSupported = false;
   /**
    * The currently-running turn's reply accumulator. Set for the duration of one
    * turn so agent_message_chunk text lands in THIS turn's buffer only. Because
@@ -2054,6 +2077,15 @@ var AcpClient = class {
         if (u.sessionUpdate === "agent_message_chunk" && u.content?.type === "text" && this.activeTurnBuffer) {
           this.activeTurnBuffer.text += u.content.text;
         }
+        if (u.sessionUpdate === "usage_update" && this.activeTurnBuffer) {
+          this.activeTurnBuffer.usage ??= {};
+          this.activeTurnBuffer.usage.contextUsed = u.used;
+          this.activeTurnBuffer.usage.contextSize = u.size;
+          if (u.cost) {
+            this.activeTurnBuffer.usage.costCumulative = u.cost.amount;
+            this.activeTurnBuffer.usage.costCurrency = u.cost.currency;
+          }
+        }
       },
       requestPermission: async (req) => {
         const verdict = evaluateAcpPermission(this.policy.mode, this.policy.configDirAbs, req);
@@ -2075,7 +2107,7 @@ var AcpClient = class {
       }
     };
     this.conn = new ClientSideConnection(() => client, stream);
-    await this.guard(
+    const init = await this.guard(
       this.conn.initialize({
         protocolVersion: 1,
         clientCapabilities: {
@@ -2085,10 +2117,29 @@ var AcpClient = class {
         clientInfo: { name: "arp-bridge", version: "0.1.0" }
       })
     );
-    const session = await this.guard(
-      this.conn.newSession({ cwd: this.launch.cwd, mcpServers: [] })
-    );
-    this._sessionId = session.sessionId;
+    this.loadSupported = init.agentCapabilities?.loadSession === true;
+    const candidateId = this._sessionId ?? this.launch.session?.persistedId ?? null;
+    let liveId = null;
+    if (candidateId && this.loadSupported) {
+      try {
+        await this.guard(
+          this.conn.loadSession({ sessionId: candidateId, cwd: this.launch.cwd, mcpServers: [] })
+        );
+        liveId = candidateId;
+      } catch (err) {
+        console.warn(
+          `[arp-bridge] session/load failed; starting a fresh session: ${sanitizeForTty(String(err?.message ?? err))}`
+        );
+      }
+    }
+    if (!liveId) {
+      const session = await this.guard(
+        this.conn.newSession({ cwd: this.launch.cwd, mcpServers: [] })
+      );
+      liveId = session.sessionId;
+    }
+    this._sessionId = liveId;
+    this.launch.session?.save(liveId);
   }
   /**
    * Send one user turn. Resolves with the full assembled reply text once the
@@ -2119,13 +2170,27 @@ var AcpClient = class {
     const buffer = { text: "" };
     this.activeTurnBuffer = buffer;
     try {
-      await this.guard(
+      const resp = await this.guard(
         this.conn.prompt({
           sessionId: this._sessionId,
           prompt: [{ type: "text", text }]
         })
       );
-      return buffer.text;
+      const u = resp?.usage;
+      if (u) {
+        buffer.usage = {
+          ...buffer.usage ?? {},
+          tokenBreakdown: {
+            inputTokens: u.inputTokens,
+            outputTokens: u.outputTokens,
+            cachedReadTokens: u.cachedReadTokens ?? void 0,
+            cachedWriteTokens: u.cachedWriteTokens ?? void 0,
+            thoughtTokens: u.thoughtTokens ?? void 0,
+            totalTokens: u.totalTokens
+          }
+        };
+      }
+      return { text: buffer.text, usage: buffer.usage };
     } finally {
       if (this.activeTurnBuffer === buffer) this.activeTurnBuffer = null;
     }
@@ -2189,6 +2254,94 @@ var AcpClient = class {
   }
 };
 
+// src/sessionStore.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, renameSync as renameSync2, chmodSync as chmodSync2 } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+function safe(s) {
+  return s.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function sessionFilePath(dir, relayUrl, agentName, channelId) {
+  return join3(dir, "sessions", relayHostSegment(relayUrl), `${safe(agentName)}__${safe(channelId)}.json`);
+}
+function loadStoredSession(dir, relayUrl, agentName, channelId) {
+  const file = sessionFilePath(dir, relayUrl, agentName, channelId);
+  let raw;
+  try {
+    raw = readFileSync2(file, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const p = JSON.parse(raw);
+    if (typeof p.sessionId === "string" && p.sessionId.trim() !== "" && typeof p.cwd === "string" && p.cwd.trim() !== "") {
+      const rec = { sessionId: p.sessionId, cwd: p.cwd };
+      if (typeof p.costCumulativeLastSeen === "number") rec.costCumulativeLastSeen = p.costCumulativeLastSeen;
+      if (typeof p.costCurrency === "string") rec.costCurrency = p.costCurrency;
+      return rec;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function saveStoredSession(dir, relayUrl, agentName, channelId, rec) {
+  const file = sessionFilePath(dir, relayUrl, agentName, channelId);
+  mkdirSync2(dirname2(file), { recursive: true, mode: 448 });
+  const tmp = `${file}.tmp-${process.pid}`;
+  writeFileSync2(tmp, JSON.stringify(rec, null, 2) + "\n", { mode: 384 });
+  renameSync2(tmp, file);
+  try {
+    chmodSync2(file, 384);
+  } catch {
+  }
+}
+function updateStoredCost(dir, relayUrl, agentName, channelId, cumulative, currency) {
+  const cur = loadStoredSession(dir, relayUrl, agentName, channelId);
+  if (!cur) return;
+  cur.costCumulativeLastSeen = cumulative;
+  if (currency) cur.costCurrency = currency;
+  saveStoredSession(dir, relayUrl, agentName, channelId, cur);
+}
+
+// src/usage/source.ts
+var AcpUsageSource = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  forTurn(raw) {
+    if (!raw || raw.contextUsed === void 0 && raw.contextSize === void 0 && raw.costCumulative === void 0 && raw.tokenBreakdown === void 0) {
+      return void 0;
+    }
+    const out = {
+      costReported: false,
+      model: this.deps.model,
+      provider: this.deps.provider,
+      authMode: this.deps.authMode
+    };
+    if (raw.contextUsed !== void 0) out.contextUsed = raw.contextUsed;
+    if (raw.contextSize !== void 0) out.contextSize = raw.contextSize;
+    if (raw.costCumulative !== void 0) {
+      out.costReported = true;
+      out.costCurrency = raw.costCurrency;
+      const prior = this.deps.loadBaseline() ?? 0;
+      const delta = Math.max(0, raw.costCumulative - prior);
+      out.costUsed = delta;
+      this.deps.saveBaseline(raw.costCumulative, raw.costCurrency);
+    }
+    if (raw.tokenBreakdown) {
+      const b = raw.tokenBreakdown;
+      out.inputTokens = b.inputTokens;
+      out.outputTokens = b.outputTokens;
+      out.cachedReadTokens = b.cachedReadTokens;
+      out.cachedWriteTokens = b.cachedWriteTokens;
+      out.thoughtTokens = b.thoughtTokens;
+      out.tokensUsed = b.totalTokens;
+    }
+    return out;
+  }
+};
+
 // src/adapter.ts
 function defaultToolPolicy() {
   return { mode: "readonly", configDirAbs: resolve2(configDir(process.env)) };
@@ -2205,9 +2358,9 @@ function pinned(pkg) {
 var npxBinaryAbs = null;
 function resolveNpxBinary() {
   if (npxBinaryAbs) return npxBinaryAbs;
-  const nodeDir = dirname2(process.execPath);
+  const nodeDir = dirname3(process.execPath);
   for (const name of ["npx", "npx.cmd"]) {
-    const candidate = join3(nodeDir, name);
+    const candidate = join4(nodeDir, name);
     if (existsSync2(candidate)) {
       npxBinaryAbs = candidate;
       return candidate;
@@ -2220,7 +2373,7 @@ function resolveNpxBinary() {
 function which(cmd, pathEnv = process.env.PATH ?? "") {
   for (const dir of pathEnv.split(delimiter)) {
     if (!dir) continue;
-    const candidate = join3(dir, cmd);
+    const candidate = join4(dir, cmd);
     try {
       accessSync(candidate, constants.X_OK);
       if (statSync(candidate).isFile()) return resolve2(candidate);
@@ -2274,13 +2427,17 @@ var defaultAcpClientFactory = (launch) => new AcpClient(launch);
 var MAX_CONSECUTIVE_RESTARTS = 3;
 var RESTART_BACKOFF_MS = 250;
 var AcpAdapter = class {
-  constructor(agent, makeClient = defaultAcpClientFactory, backoffMs = RESTART_BACKOFF_MS, policy = defaultToolPolicy()) {
+  constructor(agent, makeClient = defaultAcpClientFactory, backoffMs = RESTART_BACKOFF_MS, policy = defaultToolPolicy(), session, usageSource) {
     this.makeClient = makeClient;
     this.backoffMs = backoffMs;
+    this.session = session;
+    this.usageSource = usageSource;
     this.launch = { ...launchSpecFor(agent), policy };
   }
   makeClient;
   backoffMs;
+  session;
+  usageSource;
   launch;
   // --- supervised live state (set in start()) ---
   client = null;
@@ -2294,7 +2451,17 @@ var AcpAdapter = class {
   /** Latched once the loop guard trips, so we stop trying (and stop retrying turns). */
   gaveUp = false;
   async start(_opts) {
-    this.client = this.makeClient(this.launch);
+    const rec = this.session?.load() ?? null;
+    const cwd = rec?.cwd ?? this.launch.cwd;
+    const launch = {
+      ...this.launch,
+      cwd,
+      session: this.session ? {
+        persistedId: rec?.sessionId ?? null,
+        save: (id) => this.session.save({ sessionId: id, cwd })
+      } : void 0
+    };
+    this.client = this.makeClient(launch);
     await this.client.start();
     return {
       submit: (text) => {
@@ -2322,6 +2489,12 @@ var AcpAdapter = class {
    * never posted to the channel. A local aside on a dead/gave-up client returns a
    * clear "agent unavailable" string rather than restarting (restart supervision is
    * reserved for channel turns; a local REPL caller sees the message inline).
+   *
+   * BILLING NOTE: local asides deliberately bypass handleTurn, so they do NOT advance
+   * the cost baseline. Any cost they accrue in the warm session surfaces in the NEXT
+   * channel turn's cumulative-delta. Do NOT add a usageSource.forTurn call here — that
+   * would double-count (the same cumulative gets billed once locally and again on the
+   * next channel turn).
    */
   async converseLocal(text) {
     const client = this.client;
@@ -2329,7 +2502,7 @@ var AcpAdapter = class {
       return "[arp-bridge] agent unavailable for local conversation";
     }
     try {
-      return await client.submit(text);
+      return (await client.submit(text)).text;
     } catch (err) {
       return `[arp-bridge] local turn failed: ${err?.message ?? String(err)}`;
     }
@@ -2347,9 +2520,10 @@ var AcpAdapter = class {
     const client = this.client;
     if (!client) return false;
     try {
-      const reply = await client.submit(text);
+      const result = await client.submit(text);
       this.consecutiveRestarts = 0;
-      this.turnCbs.forEach((cb) => cb(reply));
+      const usage = this.usageSource?.forTurn(result.usage);
+      this.turnCbs.forEach((cb) => cb(result.text, usage));
       return true;
     } catch (err) {
       if (this.stopped) {
@@ -2520,14 +2694,34 @@ var ClaudeAdapter = class {
     };
   }
 };
-function createAdapter(cfg) {
+function createAdapter(cfg, channelId) {
   const policy = {
     mode: cfg.toolMode,
     configDirAbs: resolve2(configDir(process.env)),
     agentName: cfg.agentName
     // for the once-per-process "arp tools full <name>" denial hint
   };
-  return cfg.agentMode === "acp" ? new AcpAdapter(cfg.agent, void 0, void 0, policy) : new ClaudeAdapter(policy);
+  if (cfg.agentMode !== "acp") return new ClaudeAdapter(policy);
+  const session = channelId ? makeSessionPersistence(cfg, channelId) : void 0;
+  const usageSource = channelId ? makeUsageSource(cfg, channelId) : void 0;
+  return new AcpAdapter(cfg.agent, void 0, void 0, policy, session, usageSource);
+}
+function makeSessionPersistence(cfg, channelId) {
+  const dir = configDir(process.env);
+  return {
+    load: () => loadStoredSession(dir, cfg.relayWsUrl, cfg.agentName, channelId),
+    save: (rec) => saveStoredSession(dir, cfg.relayWsUrl, cfg.agentName, channelId, rec)
+  };
+}
+function makeUsageSource(cfg, channelId) {
+  const dir = configDir(process.env);
+  return new AcpUsageSource({
+    model: cfg.model,
+    provider: cfg.agent,
+    authMode: cfg.agentMode === "acp" ? "oauth" : "apikey",
+    loadBaseline: () => loadStoredSession(dir, cfg.relayWsUrl, cfg.agentName, channelId)?.costCumulativeLastSeen,
+    saveBaseline: (cumulative, currency) => updateStoredCost(dir, cfg.relayWsUrl, cfg.agentName, channelId, cumulative, currency)
+  });
 }
 
 // src/elicit.ts
@@ -2612,15 +2806,15 @@ async function startBridge(cfg, relay, deps) {
     const inFlight = pending.get(channelId);
     if (inFlight) return inFlight;
     const p = (async () => {
-      const adapter = deps.makeAdapter(cfg);
+      const adapter = deps.makeAdapter(cfg, channelId);
       const beacon = new ActivityBeacon((state) => relay.sendActivity(channelId, state));
       const session = new ChannelSession(
         adapter,
-        (text) => void relay.postMessage(channelId, text),
+        (text, usage) => void relay.postMessage(channelId, text, usage),
         cfg.agentName,
         channelId,
         {
-          postReply: (flowId, content) => relay.postFlowMessage(channelId, flowId, content),
+          postReply: (flowId, content, usage) => relay.postFlowMessage(channelId, flowId, content, usage),
           fetchHistory: (flowId) => relay.fetchFlowMessages(channelId, flowId)
         },
         () => relay.fetchChannelContext(channelId),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowyroad/arp",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "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",