@agentconnect.md/daemon 1.0.0-rc.52 → 1.0.0-rc.53

package/dist/index.js

@@ -17142,11 +17142,18 @@ var AcpHost = class {
 			this.loadingSessions.delete(sessionId);
 		}
 	}
+	/** Drive one turn to completion. Returns the stop reason plus the agent's token
+	*  `usage` when the runtime reports it (ACP's experimental per-turn usage, which
+	*  carries session-cumulative counts) — `undefined` when it doesn't. */
 	async prompt(sessionId, blocks) {
-		return (await this.conn.agent.request(methods.agent.session.prompt, {
+		const res = await this.conn.agent.request(methods.agent.session.prompt, {
 			sessionId,
 			prompt: blocks
-		})).stopReason;
+		});
+		return {
+			stopReason: res.stopReason,
+			usage: res.usage ?? void 0
+		};
 	}
 	async cancel(sessionId) {
 		await this.conn.agent.notify(methods.agent.session.cancel, { sessionId });
@@ -17638,6 +17645,25 @@ const RegisterOk = object({
 *   online daemons and merges, for "all sessions across the workspace").
 * - `session/history`: one cursor-paginated page of a session's transcript.
 */
+/**
+* Per-session token accounting, metered by the daemon from the agent's ACP usage
+* stream. Token counts are CUMULATIVE across the session's turns (summed from each
+* turn's `PromptResponse.usage`); context/cost are the LATEST snapshot from the
+* agent's `usage_update` stream. Every field is optional — a runtime that reports
+* no usage yields an absent field, not a zero.
+*/
+const SessionUsage = object({
+	totalTokens: number().int().optional(),
+	inputTokens: number().int().optional(),
+	outputTokens: number().int().optional(),
+	thoughtTokens: number().int().optional(),
+	cachedReadTokens: number().int().optional(),
+	cachedWriteTokens: number().int().optional(),
+	contextUsed: number().int().optional(),
+	contextSize: number().int().optional(),
+	costAmount: number().optional(),
+	costCurrency: string().optional()
+});
 /** One row in the session list (metadata + console metrics; NOT the transcript). */
 const SessionListItem = object({
 	sessionId: string(),
@@ -17646,7 +17672,7 @@ const SessionListItem = object({
 	title: string().optional(),
 	status: string().optional(),
 	lastActivityAt: string().optional(),
-	tokenUsage: number().int().optional(),
+	usage: SessionUsage.optional(),
 	triggeredBy: string().optional()
 });
 /** C→D REQ: list the daemon's sessions (optionally just one agent's). */
@@ -17739,6 +17765,14 @@ const FRAME_SCHEMAS = {
 		summary: string().optional(),
 		ts: string().datetime()
 	}),
+	"usage/report": object({
+		sessionId: string(),
+		agentId: string().uuid(),
+		platform: string().optional(),
+		channel: string().optional(),
+		lastActivityAt: string(),
+		usage: SessionUsage
+	}),
 	"facts/runtime-profile": object({
 		runtime: string(),
 		version: string(),
@@ -17842,6 +17876,7 @@ discriminatedUnion("type", [
 	frame("secrets/revoke", FRAME_SCHEMAS["secrets/revoke"]),
 	frame("scope-attestation", FRAME_SCHEMAS["scope-attestation"]),
 	frame("event/session", FRAME_SCHEMAS["event/session"]),
+	frame("usage/report", FRAME_SCHEMAS["usage/report"]),
 	frame("facts/runtime-profile", FRAME_SCHEMAS["facts/runtime-profile"]),
 	frame("session/list", FRAME_SCHEMAS["session/list"]),
 	frame("session/list/page", FRAME_SCHEMAS["session/list/page"]),
@@ -23568,7 +23603,8 @@ var LocalStore = class {
 		this.db.exec(`
       CREATE TABLE IF NOT EXISTS sessions (
         key TEXT PRIMARY KEY, agentId TEXT, platform TEXT, channel TEXT, thread TEXT,
-        acpSessionId TEXT, state TEXT, lastDeliveredTs TEXT, updatedAt INTEGER
+        acpSessionId TEXT, state TEXT, lastDeliveredTs TEXT, updatedAt INTEGER,
+        usage TEXT
       );
       CREATE TABLE IF NOT EXISTS transcript (
         seq INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -23585,6 +23621,13 @@ var LocalStore = class {
         routingEpoch INTEGER, assignments TEXT, globalRules TEXT
       );
     `);
+		this.migrateSessionUsage();
+	}
+	/** Add the `sessions.usage` column (JSON token accounting) to a pre-existing DB.
+	*  CREATE TABLE IF NOT EXISTS above adds it for fresh DBs but never alters an
+	*  existing table, so upgrade in place. No-op once the column is present. */
+	migrateSessionUsage() {
+		if (!this.db.prepare("PRAGMA table_info(sessions)").all().some((c) => c.name === "usage")) this.db.exec("ALTER TABLE sessions ADD COLUMN usage TEXT");
 	}
 	/**
 	* Pre-`kind` transcript tables keyed on (channel, thread, ts) hold only conversational
@@ -23610,7 +23653,8 @@ var LocalStore = class {
 		return this.db.prepare("SELECT * FROM sessions WHERE key = ?").get(key);
 	}
 	/** All sessions that have an ACP id (i.e. are addressable by sessionId), newest
-	*  first. Optionally scoped to one agent. Backs `session/list` read-back. */
+	*  first. Optionally scoped to one agent. Backs `session/list` read-back — the
+	*  `usage` column comes back as raw JSON (parsed by the reader). */
 	listSessions(agentId) {
 		if (agentId !== void 0) return this.db.prepare("SELECT * FROM sessions WHERE acpSessionId IS NOT NULL AND agentId = ? ORDER BY updatedAt DESC").all(agentId);
 		return this.db.prepare("SELECT * FROM sessions WHERE acpSessionId IS NOT NULL ORDER BY updatedAt DESC").all();
@@ -23637,7 +23681,17 @@ var LocalStore = class {
          VALUES (@key, @agentId, @platform, @channel, @thread, @acpSessionId, @state, @lastDeliveredTs, @updatedAt)
          ON CONFLICT(key) DO UPDATE SET
            acpSessionId=excluded.acpSessionId, state=excluded.state,
-           lastDeliveredTs=excluded.lastDeliveredTs, updatedAt=excluded.updatedAt`).run(rec);
+           lastDeliveredTs=excluded.lastDeliveredTs, updatedAt=excluded.updatedAt`).run({
+			key: rec.key,
+			agentId: rec.agentId,
+			platform: rec.platform,
+			channel: rec.channel,
+			thread: rec.thread,
+			acpSessionId: rec.acpSessionId,
+			state: rec.state,
+			lastDeliveredTs: rec.lastDeliveredTs,
+			updatedAt: rec.updatedAt
+		});
 	}
 	/** Targeted state transition for an existing session (§7.3), stamping `updatedAt`
 	*  so the change counts as activity for the TTL/idle clocks. No-op if the key is
@@ -23645,6 +23699,45 @@ var LocalStore = class {
 	setSessionState(key, state, updatedAt) {
 		this.db.prepare("UPDATE sessions SET state = ?, updatedAt = ? WHERE key = ?").run(state, updatedAt, key);
 	}
+	/** Current token accounting for a session (parsed from the `usage` JSON column),
+	*  or `{}` if none has been recorded / the JSON is unreadable. */
+	getUsage(key) {
+		const row = this.db.prepare("SELECT usage FROM sessions WHERE key = ?").get(key);
+		if (!row?.usage) return {};
+		try {
+			return JSON.parse(row.usage);
+		} catch {
+			return {};
+		}
+	}
+	writeUsage(key, u) {
+		this.db.prepare("UPDATE sessions SET usage = ? WHERE key = ?").run(JSON.stringify(u), key);
+	}
+	/** Record the latest token counts for a session. ACP's `Usage` is already the
+	*  running session total (not a per-turn delta), so this is latest-wins over the
+	*  token fields — never additive. Only provided fields are updated; the
+	*  context/cost snapshot is left intact. No-op on an unknown key (the row is
+	*  created by the SessionManager first). */
+	setTokenUsage(key, counts) {
+		const u = this.getUsage(key);
+		if (counts.totalTokens !== void 0) u.totalTokens = counts.totalTokens;
+		if (counts.inputTokens !== void 0) u.inputTokens = counts.inputTokens;
+		if (counts.outputTokens !== void 0) u.outputTokens = counts.outputTokens;
+		if (counts.thoughtTokens !== void 0) u.thoughtTokens = counts.thoughtTokens;
+		if (counts.cachedReadTokens !== void 0) u.cachedReadTokens = counts.cachedReadTokens;
+		if (counts.cachedWriteTokens !== void 0) u.cachedWriteTokens = counts.cachedWriteTokens;
+		this.writeUsage(key, u);
+	}
+	/** Overwrite the session's context-window + cost snapshot (latest `usage_update`
+	*  wins). Only provided fields are updated. No-op on an unknown key. */
+	setUsageSnapshot(key, snap) {
+		const u = this.getUsage(key);
+		if (snap.contextUsed !== void 0) u.contextUsed = snap.contextUsed;
+		if (snap.contextSize !== void 0) u.contextSize = snap.contextSize;
+		if (snap.costAmount !== void 0) u.costAmount = snap.costAmount;
+		if (snap.costCurrency !== void 0) u.costCurrency = snap.costCurrency;
+		this.writeUsage(key, u);
+	}
 	/** Most-recent activity across an agent's non-closed sessions (epoch ms), or null
 	*  if it has none. Drives idle-host reaping (#111): a host with no recent session
 	*  activity AND no in-flight turn is past its idle window. */
@@ -81942,6 +82035,17 @@ var CpClient = class {
 		if (this.state !== "READY" && this.state !== "DRAINING") return;
 		this.transport?.send(encode(buildEnvelope("facts/runtime-profile", profile)));
 	}
+	/**
+	* Report a session's cumulative token usage (D→C `usage/report` EVT,
+	* fire-and-forget). No-op unless READY/DRAINING — usage is dashboard telemetry,
+	* so a dropped report just means that turn's delta is absent from the CP's
+	* historical aggregates until the next report (which re-sends the cumulative
+	* snapshot, latest-wins). Never blocks the turn.
+	*/
+	emitUsageReport(report) {
+		if (this.state !== "READY" && this.state !== "DRAINING") return;
+		this.transport?.send(encode(buildEnvelope("usage/report", report)));
+	}
 	request(type, payload) {
 		const frame = buildEnvelope(type, payload);
 		return this.correlator.request(frame, (e) => this.transport.send(e));
@@ -82114,20 +82218,35 @@ var CpClient = class {
 };
 //#endregion
 //#region src/cp/session-reader.ts
+/** Parse a session row's `usage` JSON into the wire shape. Returns undefined when
+*  absent, empty, or unparseable so the optional field is simply omitted. */
+function parseUsage(raw) {
+	if (!raw) return void 0;
+	try {
+		const u = JSON.parse(raw);
+		return u && Object.keys(u).length > 0 ? u : void 0;
+	} catch {
+		return;
+	}
+}
 function createSessionReader(store) {
 	return {
 		list(req) {
-			return { sessions: store.listSessions(req.agentId).map((r) => ({
-				sessionId: r.acpSessionId,
-				sessionKey: {
-					platform: r.platform,
-					channel: r.channel,
-					thread: r.thread
-				},
-				agentId: r.agentId,
-				status: r.state,
-				lastActivityAt: new Date(r.updatedAt).toISOString()
-			})) };
+			return { sessions: store.listSessions(req.agentId).map((r) => {
+				const usage = parseUsage(r.usage);
+				return {
+					sessionId: r.acpSessionId,
+					sessionKey: {
+						platform: r.platform,
+						channel: r.channel,
+						thread: r.thread
+					},
+					agentId: r.agentId,
+					status: r.state,
+					lastActivityAt: new Date(r.updatedAt).toISOString(),
+					...usage ? { usage } : {}
+				};
+			}) };
 		},
 		history(req) {
 			const rec = store.getSessionByAcpId(req.sessionId);
@@ -83118,7 +83237,28 @@ var Daemon = class Daemon {
 		try {
 			const host = await this.ensureHostAsync(agentId);
 			if (!wasRunning) replyConn?.setStatus(msg.channel, statusThread, "is thinking…");
-			await host.prompt(sessionId, blocks);
+			const { usage } = await host.prompt(sessionId, blocks);
+			if (usage) this.store.setTokenUsage(key, {
+				totalTokens: usage.totalTokens,
+				inputTokens: usage.inputTokens,
+				outputTokens: usage.outputTokens,
+				thoughtTokens: usage.thoughtTokens ?? void 0,
+				cachedReadTokens: usage.cachedReadTokens ?? void 0,
+				cachedWriteTokens: usage.cachedWriteTokens ?? void 0
+			});
+			const mergedUsage = this.store.getUsage(key);
+			if (Object.keys(mergedUsage).length > 0) try {
+				this.cpClient?.emitUsageReport({
+					sessionId,
+					agentId,
+					platform: msg.platform,
+					channel: msg.channel,
+					lastActivityAt: new Date(this.clock.now()).toISOString(),
+					usage: mergedUsage
+				});
+			} catch (err) {
+				this.log.debug(`usage report emit failed (session ${sessionId}): ${err.message}`);
+			}
 			this.clearIdle(p);
 			const link = this.cfg.webAppUrl ? `${this.cfg.webAppUrl.replace(/\/$/, "")}/sessions/${sessionId}` : void 0;
 			for (const action of conv.onFinal(link)) this.enqueueApply(p, action);
@@ -83227,6 +83367,12 @@ var Daemon = class Daemon {
 	onAcpUpdate(_agentId, sessionId, update) {
 		const p = this.pending.get(sessionId);
 		if (!p) return;
+		if (update?.sessionUpdate === "usage_update") this.store.setUsageSnapshot(p.sessionKey, {
+			contextUsed: update.used,
+			contextSize: update.size,
+			costAmount: update.cost?.amount ?? void 0,
+			costCurrency: update.cost?.currency ?? void 0
+		});
 		for (const action of p.conv.onUpdate(update)) this.enqueueApply(p, action);
 		this.armIdle(p);
 		for (const ev of p.rec.onUpdate(update)) this.recordEvent(p.agentId, p.channel, p.statusThread, ev);