@agentconnect.md/daemon 1.0.0-rc.79 → 1.0.0-rc.80

package/dist/index.js

@@ -13257,6 +13257,19 @@ const SessionListItem = object({
 const SessionListReq = object({ agentId: string().uuid().optional() });
 /** D→C REP (corr = req id): the daemon's current sessions. */
 const SessionListPage = object({ sessions: array(SessionListItem) });
+object({
+	toolCallId: string(),
+	kind: string().optional(),
+	status: string().optional(),
+	rawInput: unknown().optional(),
+	rawOutput: unknown().optional(),
+	content: array(unknown()).optional(),
+	locations: array(object({
+		path: string(),
+		line: number().int().optional()
+	})).optional(),
+	truncated: boolean().optional()
+});
 /** One message in a session transcript page (a body — returned only for display). */
 const SessionMessage = object({
 	seq: number().int(),
@@ -13264,7 +13277,13 @@ const SessionMessage = object({
 	senderName: string().optional(),
 	ts: string(),
 	kind: string(),
-	text: string()
+	text: string(),
+	toolCallId: string().optional(),
+	toolStatus: string().optional(),
+	toolKind: string().optional(),
+	body: string().optional(),
+	bodyTruncated: boolean().optional(),
+	bodyBytes: number().int().optional()
 });
 /** C→D REQ: fetch one page of a session's history from the owning daemon. */
 const SessionHistoryReq = object({
@@ -13278,6 +13297,24 @@ const SessionHistoryPage = object({
 	messages: array(SessionMessage),
 	nextCursor: string().optional()
 });
+/**
+* C→D REQ: fetch the FULL (untruncated) ToolBody JSON for one tool call, chunked.
+* The inline `SessionMessage.body` preview is capped at 32 KiB; when a body is
+* bigger the console pages the whole thing back through this frame by offset.
+*/
+const SessionToolBodyReq = object({
+	sessionId: string(),
+	toolCallId: string(),
+	offset: number().int().nonnegative().default(0)
+});
+/** D→C REP (corr = the req id): one frame-budgeted byte slice of the full ToolBody JSON. */
+const SessionToolBodyChunk = object({
+	sessionId: string(),
+	toolCallId: string(),
+	data: string(),
+	totalBytes: number().int(),
+	nextOffset: number().int().optional()
+});
 //#endregion
 //#region ../protocol/dist/frames/workspace.js
 /**
@@ -13518,6 +13555,8 @@ const FRAME_SCHEMAS = {
 	"session/list/page": SessionListPage,
 	"session/history": SessionHistoryReq,
 	"session/history/page": SessionHistoryPage,
+	"session/tool-body": SessionToolBodyReq,
+	"session/tool-body/chunk": SessionToolBodyChunk,
 	"workspace/list": WorkspaceListReq,
 	"workspace/list/page": WorkspaceListPage,
 	"workspace/read": WorkspaceReadReq,
@@ -13621,6 +13660,8 @@ discriminatedUnion("type", [
 	frame("session/list/page", FRAME_SCHEMAS["session/list/page"]),
 	frame("session/history", FRAME_SCHEMAS["session/history"]),
 	frame("session/history/page", FRAME_SCHEMAS["session/history/page"]),
+	frame("session/tool-body", FRAME_SCHEMAS["session/tool-body"]),
+	frame("session/tool-body/chunk", FRAME_SCHEMAS["session/tool-body/chunk"]),
 	frame("workspace/list", FRAME_SCHEMAS["workspace/list"]),
 	frame("workspace/list/page", FRAME_SCHEMAS["workspace/list/page"]),
 	frame("workspace/read", FRAME_SCHEMAS["workspace/read"]),
@@ -23865,13 +23906,17 @@ var LocalStore = class {
       CREATE TABLE IF NOT EXISTS transcript (
         seq INTEGER PRIMARY KEY AUTOINCREMENT,
         channel TEXT NOT NULL, thread TEXT NOT NULL, ts TEXT,
-        sender TEXT NOT NULL, kind TEXT NOT NULL, text TEXT NOT NULL
+        sender TEXT NOT NULL, kind TEXT NOT NULL, text TEXT NOT NULL,
+        tool_call_id TEXT, body TEXT
       );
       CREATE INDEX IF NOT EXISTS transcript_thread_seq ON transcript (channel, thread, seq);
       -- Dedup conversational rows by platform ts (double-fired inbound / redelivery);
       -- internal events have no platform ts and are intentionally never deduped here.
       CREATE UNIQUE INDEX IF NOT EXISTS transcript_text_ts
         ON transcript (channel, thread, ts) WHERE kind = 'text';
+      -- transcript_tool_call (partial unique on tool_call_id) is created in
+      -- migrateTranscriptToolBody, after the column is guaranteed to exist — a legacy
+      -- rebuild in migrateTranscript recreates the table without the new columns.
       CREATE TABLE IF NOT EXISTS cp_routing (
         id INTEGER PRIMARY KEY CHECK (id = 1),
         routingEpoch INTEGER, assignments TEXT, globalRules TEXT
@@ -23883,6 +23928,18 @@ var LocalStore = class {
       );
     `);
 		this.migrateSessionUsage();
+		this.migrateTranscriptToolBody();
+	}
+	/** Add the `transcript.tool_call_id` + `transcript.body` columns (and the partial
+	*  unique index) to a pre-existing DB. CREATE TABLE IF NOT EXISTS above adds them for
+	*  fresh DBs but never alters an existing table, so upgrade in place. No-op once the
+	*  columns are present. */
+	migrateTranscriptToolBody() {
+		const cols = this.db.prepare("PRAGMA table_info(transcript)").all();
+		if (!cols.some((c) => c.name === "tool_call_id")) this.db.exec("ALTER TABLE transcript ADD COLUMN tool_call_id TEXT");
+		if (!cols.some((c) => c.name === "body")) this.db.exec("ALTER TABLE transcript ADD COLUMN body TEXT");
+		this.db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS transcript_tool_call
+         ON transcript (channel, thread, tool_call_id) WHERE tool_call_id IS NOT NULL`);
 	}
 	/** Add the `sessions.usage` (JSON token accounting), `sessions.muted` (`!stop`
 	*  thread mute) and `sessions.triggeredBy` columns to a pre-existing DB. CREATE
@@ -24032,6 +24089,32 @@ var LocalStore = class {
 	appendTranscript(e) {
 		this.db.prepare("INSERT OR IGNORE INTO transcript (channel, thread, ts, sender, kind, text) VALUES (@channel, @thread, @ts, @sender, @kind, @text)").run(e);
 	}
+	/** First sight of a tool call: insert its kind='tool' row (title in `text`, the
+	*  serialized ToolBody in `body`). INSERT OR IGNORE so a re-fired first update is a
+	*  no-op — the partial unique index on (channel, thread, tool_call_id) dedups. `seq`
+	*  is assigned here and stays stable across later `updateToolCall`s. */
+	insertToolCall(e) {
+		this.db.prepare(`INSERT OR IGNORE INTO transcript (channel, thread, ts, sender, kind, text, tool_call_id, body)
+         VALUES (@channel, @thread, @ts, @sender, 'tool', @text, @toolCallId, @body)`).run({
+			channel: e.channel,
+			thread: e.thread,
+			ts: e.ts,
+			sender: e.sender,
+			text: e.title,
+			toolCallId: e.toolCallId,
+			body: e.body
+		});
+	}
+	/** Later update for a tool call: overwrite `text` (title) + `body` on the existing
+	*  row, keyed by (channel, thread, tool_call_id). `seq`/`ts` are untouched so the
+	*  row keeps its first-seen position. No-op if the row is absent. */
+	updateToolCall(channel, thread, toolCallId, patch) {
+		this.db.prepare("UPDATE transcript SET text = ?, body = ? WHERE channel = ? AND thread = ? AND tool_call_id = ?").run(patch.title, patch.body, channel, thread, toolCallId);
+	}
+	/** The full stored ToolBody JSON for one tool call, or undefined if unknown. */
+	getToolBody(channel, thread, toolCallId) {
+		return this.db.prepare("SELECT body FROM transcript WHERE channel = ? AND thread = ? AND tool_call_id = ?").get(channel, thread, toolCallId)?.body ?? void 0;
+	}
 	/**
 	* §8.5 cross-agent catch-up: conversational (`text`) rows only — tool/reasoning rows
 	* are audit/UI data and must never be replayed back into an agent's prompt. Ordered by
@@ -24294,6 +24377,9 @@ function transcriptCoords(msg) {
 }
 //#endregion
 //#region src/session/transcript-recorder.ts
+/** Single-body write ceiling (protects the daemon DB from a huge rawOutput/content);
+*  separate from the read-side 32 KiB inline preview cap. */
+const MAX_TOOL_BODY_BYTES = 1024 * 1024;
 /**
 * Turns the raw ACP `session/update` stream into the *full* activity log — tool calls
 * and reasoning — independent of the agent's Slack `output.mode`. (Output mode only
@@ -24302,12 +24388,14 @@ function transcriptCoords(msg) {
 * It deliberately does NOT emit `text`: conversational rows are recorded at the
 * platform-send boundary instead, where the real message `ts` is known (so they sort
 * against the §8.5 replay marker). Reasoning chunks are coalesced into one block per
-* run; each tool invocation is recorded once (keyed by toolCallId, so the burst of
-* `tool_call_update`s for one call collapses to a single row).
+* run; each tool invocation is merged per `toolCallId` across its `tool_call` +
+* `tool_call_update` burst — emitting an `insert` on first sight and an `update` on
+* each later change, so the row's full body fills in as the call streams to completion.
 */
 var TranscriptRecorder = class {
 	thought = "";
-	seenTools = /* @__PURE__ */ new Set();
+	tools = /* @__PURE__ */ new Map();
+	titles = /* @__PURE__ */ new Map();
 	onUpdate(update) {
 		switch (update.sessionUpdate) {
 			case "agent_thought_chunk": {
@@ -24320,11 +24408,17 @@ var TranscriptRecorder = class {
 				const flushed = this.flushThought();
 				const u = update;
 				const id = u.toolCallId ?? "";
-				if (id && this.seenTools.has(id)) return flushed;
-				if (id) this.seenTools.add(id);
+				if (!id) return flushed;
+				const first = !this.tools.has(id);
+				const body = this.merge(id, u);
+				const title = u.title ?? this.titles.get(id) ?? id;
+				if (u.title !== void 0 && u.title !== null) this.titles.set(id, u.title);
 				return [...flushed, {
 					kind: "tool",
-					text: u.title ?? (id || "tool")
+					op: first ? "insert" : "update",
+					toolCallId: id,
+					text: title,
+					body: serializeBody(body)
 				}];
 			}
 			case "agent_message_chunk": return this.flushThought();
@@ -24335,6 +24429,23 @@ var TranscriptRecorder = class {
 	onFinal() {
 		return this.flushThought();
 	}
+	/**
+	* Merge one `tool_call`/`tool_call_update` into the accumulated ToolBody per ACP
+	* semantics: present-and-non-null scalar fields (kind/status/rawInput/rawOutput)
+	* overlay the prior value; `content`/`locations` are wholesale replacements when
+	* present. Returns the updated body (also cached in `tools`).
+	*/
+	merge(id, u) {
+		const body = this.tools.get(id) ?? { toolCallId: id };
+		if (u.kind !== void 0 && u.kind !== null) body.kind = u.kind;
+		if (u.status !== void 0 && u.status !== null) body.status = u.status;
+		if (u.rawInput !== void 0 && u.rawInput !== null) body.rawInput = u.rawInput;
+		if (u.rawOutput !== void 0 && u.rawOutput !== null) body.rawOutput = u.rawOutput;
+		if (u.content !== void 0 && u.content !== null) body.content = u.content;
+		if (u.locations !== void 0 && u.locations !== null) body.locations = u.locations;
+		this.tools.set(id, body);
+		return body;
+	}
 	flushThought() {
 		const text = this.thought.trim();
 		this.thought = "";
@@ -24344,6 +24455,25 @@ var TranscriptRecorder = class {
 		}] : [];
 	}
 };
+/** Serialize a ToolBody, capping the encoded size at MAX_TOOL_BODY_BYTES. When over
+*  cap, drop the biggest free-form tails (rawOutput first, then content) and flag
+*  `truncated` so the read side / UI can show it was capped at write time. */
+function serializeBody(body) {
+	let json = JSON.stringify(body);
+	if (Buffer.byteLength(json) <= MAX_TOOL_BODY_BYTES) return json;
+	const capped = {
+		...body,
+		truncated: true
+	};
+	capped.rawOutput = void 0;
+	json = JSON.stringify(capped);
+	if (Buffer.byteLength(json) <= MAX_TOOL_BODY_BYTES) return json;
+	capped.content = void 0;
+	json = JSON.stringify(capped);
+	if (Buffer.byteLength(json) <= MAX_TOOL_BODY_BYTES) return json;
+	capped.rawInput = void 0;
+	return JSON.stringify(capped);
+}
 //#endregion
 //#region src/mcp/ipc.ts
 /** Frame a message for the wire: compact JSON + a single trailing newline. */
@@ -82323,7 +82453,7 @@ function makeLogger(level = "info") {
 const SNIFF_BYTES = 8192;
 /** Encoded-payload ceiling, leaving headroom under MAX_FRAME_BYTES for the
 *  envelope (id/ts/type/corr + fencing ext, well under 4 KiB). */
-const REPLY_BUDGET = MAX_FRAME_BYTES - 4096;
+const REPLY_BUDGET$1 = MAX_FRAME_BYTES - 4096;
 /** Path-containment / bad-request violation → `BAD_PAYLOAD` on the wire. */
 var WorkspaceViolationError = class extends Error {
 	constructor(message) {
@@ -82340,7 +82470,7 @@ function under(root, p) {
 /** Largest index ≤ `len` that lands on a UTF-8 character boundary — i.e. never
 *  cuts a multi-byte sequence. If the slice's trailing char is incomplete, the
 *  boundary is placed before that char (its bytes belong to the next slice). */
-function utf8Boundary(buf, len) {
+function utf8Boundary$1(buf, len) {
 	if (len >= buf.length) len = buf.length;
 	if (len <= 0) return 0;
 	let start = len - 1;
@@ -82351,7 +82481,7 @@ function utf8Boundary(buf, len) {
 }
 /** The encoded size of the payload the wire will carry (JSON.stringify matches
 *  the codec's `encode`), measured in bytes. */
-function encodedBytes(payload) {
+function encodedBytes$1(payload) {
 	return Buffer.byteLength(JSON.stringify(payload));
 }
 function createWorkspaceReader(workspaceRootByAgent) {
@@ -82435,8 +82565,8 @@ function createWorkspaceReader(workspaceRootByAgent) {
 			let acc = 0;
 			for (let i = start; i < entries.length && page.length < req.limit; i++) {
 				const e = entries[i];
-				const enc = encodedBytes(e) + 1;
-				if (page.length > 0 && acc + enc > REPLY_BUDGET) break;
+				const enc = encodedBytes$1(e) + 1;
+				if (page.length > 0 && acc + enc > REPLY_BUDGET$1) break;
 				page.push(e);
 				acc += enc;
 			}
@@ -82490,12 +82620,12 @@ function createWorkspaceReader(workspaceRootByAgent) {
 					const { bytesRead } = await fh.read(buf, 0, want, req.offset);
 					slice = buf.subarray(0, bytesRead);
 				}
-				let end = utf8Boundary(slice, slice.length);
+				let end = utf8Boundary$1(slice, slice.length);
 				let content = slice.toString("utf8", 0, end);
-				while (end > 0 && encodedBytes(content) > REPLY_BUDGET) {
-					const factor = REPLY_BUDGET / encodedBytes(content);
+				while (end > 0 && encodedBytes$1(content) > REPLY_BUDGET$1) {
+					const factor = REPLY_BUDGET$1 / encodedBytes$1(content);
 					const shrunk = Math.max(1, Math.floor(end * factor * .9));
-					end = utf8Boundary(slice, Math.min(shrunk, end - 1));
+					end = utf8Boundary$1(slice, Math.min(shrunk, end - 1));
 					content = slice.toString("utf8", 0, end);
 				}
 				const nextOffset = req.offset + end;
@@ -82893,6 +83023,13 @@ var CpClient = class {
 					this.sendError(frame.id, "INTERNAL", `session/history failed: ${err.message}`, false);
 				}
 				return;
+			case "session/tool-body":
+				try {
+					this.reply(frame, "session/tool-body/chunk", this.deps.sessionRead.toolBody(frame.payload));
+				} catch (err) {
+					this.sendError(frame.id, "INTERNAL", `session/tool-body failed: ${err.message}`, false);
+				}
+				return;
 			case "workspace/list":
 				this.deps.workspaceRead.list(frame.payload).then((page) => this.reply(frame, "workspace/list/page", page)).catch((err) => this.workspaceError(frame.id, "workspace/list", err));
 				return;
@@ -82935,6 +83072,40 @@ var CpClient = class {
 };
 //#endregion
 //#region src/cp/session-reader.ts
+/**
+* `SessionReader` — the read-only seam answering the CP's `session/list`,
+* `session/history` and `session/tool-body` REQs from the daemon's local store.
+* Bodies live only on the daemon (§1/§12); this projects store rows onto the
+* protocol shapes. The protocol `sessionId` IS the store's `acpSessionId`
+* (SessionManager returns it).
+*
+* Frame-size safety: every REP must serialise under the 256 KiB wire cap. A single
+* tool body can be large, so `history` caps each inline `body` at a 32 KiB VALID-JSON
+* preview and assembles a page under the per-frame budget (newest rows that fit);
+* the FULL body is pulled on demand via `toolBody`, chunked by offset.
+*/
+/** Encoded-payload ceiling, leaving headroom under MAX_FRAME_BYTES for the
+*  envelope (id/ts/type/corr + fencing ext, well under 4 KiB). */
+const REPLY_BUDGET = MAX_FRAME_BYTES - 4096;
+/** Inline `SessionMessage.body` preview cap. Bodies over this are shrunk to a
+*  valid-JSON preview + `bodyTruncated`; the full body is fetched via `toolBody`. */
+const PREVIEW_CAP = 32 * 1024;
+/** The encoded size of the payload the wire will carry (JSON.stringify matches the
+*  codec's `encode`), measured in bytes. */
+function encodedBytes(payload) {
+	return Buffer.byteLength(JSON.stringify(payload));
+}
+/** Largest index ≤ `len` that lands on a UTF-8 character boundary — never cuts a
+*  multi-byte sequence (mirrors workspace-reader's slicer). */
+function utf8Boundary(buf, len) {
+	if (len >= buf.length) len = buf.length;
+	if (len <= 0) return 0;
+	let start = len - 1;
+	while (start > 0 && ((buf[start] ?? 0) & 192) === 128) start--;
+	const lead = buf[start] ?? 0;
+	const seqLen = lead < 128 ? 1 : (lead & 224) === 192 ? 2 : (lead & 240) === 224 ? 3 : (lead & 248) === 240 ? 4 : 1;
+	return start + seqLen <= len ? len : start;
+}
 /** 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) {
@@ -82946,6 +83117,46 @@ function parseUsage(raw) {
 		return;
 	}
 }
+/** Rough character budget to trim a free-form value to when shrinking a preview. A
+*  string is truncated to this many chars; a non-string is stringified then truncated
+*  (kept as a string — the preview is still valid JSON, just lossy on that field). */
+function shrinkField(value, chars) {
+	if (value === void 0) return void 0;
+	const s = typeof value === "string" ? value : JSON.stringify(value);
+	if (s.length <= chars) return value;
+	return s.slice(0, chars) + "…";
+}
+/**
+* Build a VALID-JSON preview of a tool body that encodes within PREVIEW_CAP. The
+* heavy free-form fields (rawOutput, rawInput, content) are trimmed progressively
+* until it fits; `truncated`/status/kind/locations are preserved. Always sets
+* `truncated:true` on the returned preview.
+*/
+function previewBody(full) {
+	const preview = {
+		...full,
+		truncated: true
+	};
+	for (const chars of [
+		8192,
+		2048,
+		512,
+		128,
+		16
+	]) {
+		preview.rawOutput = shrinkField(full.rawOutput, chars);
+		preview.rawInput = shrinkField(full.rawInput, chars);
+		if (full.content !== void 0) {
+			const asStr = JSON.stringify(full.content);
+			preview.content = asStr.length <= chars ? full.content : [shrinkField(asStr, chars)];
+		}
+		if (encodedBytes(preview) <= PREVIEW_CAP) return preview;
+	}
+	preview.rawOutput = void 0;
+	preview.rawInput = void 0;
+	preview.content = void 0;
+	return preview;
+}
 function createSessionReader(store) {
 	return {
 		list(req) {
@@ -82982,9 +83193,9 @@ function createSessionReader(store) {
 			const { rows, hasMore } = store.transcriptPage(rec.channel, rec.thread, before, req.limit);
 			const ordered = rows.slice().reverse();
 			const names = store.getDisplayNames(ordered.map((r) => r.sender));
-			const messages = ordered.map((r) => {
+			const built = ordered.map((r) => {
 				const senderName = names.get(r.sender);
-				return {
+				const base = {
 					seq: r.seq,
 					sender: r.sender,
 					...senderName ? { senderName } : {},
@@ -82992,11 +83203,76 @@ function createSessionReader(store) {
 					kind: r.kind,
 					text: r.text
 				};
+				if (r.kind !== "tool" || !r.body) return base;
+				let full;
+				try {
+					full = JSON.parse(r.body);
+				} catch {
+					return base;
+				}
+				const bytes = Buffer.byteLength(r.body);
+				base.toolCallId = full.toolCallId ?? r.toolCallId ?? void 0;
+				if (full.status !== void 0) base.toolStatus = full.status;
+				if (full.kind !== void 0) base.toolKind = full.kind;
+				if (bytes <= PREVIEW_CAP) base.body = r.body;
+				else {
+					base.body = JSON.stringify(previewBody(full));
+					base.bodyTruncated = true;
+					base.bodyBytes = bytes;
+				}
+				return base;
 			});
+			const kept = [];
+			let acc = 0;
+			let droppedToBudget = false;
+			for (let i = built.length - 1; i >= 0; i--) {
+				const m = built[i];
+				const enc = encodedBytes(m) + 1;
+				if (kept.length > 0 && acc + enc > REPLY_BUDGET) {
+					droppedToBudget = true;
+					break;
+				}
+				kept.push(m);
+				acc += enc;
+			}
+			kept.reverse();
+			const hasOlder = hasMore || droppedToBudget;
 			return {
 				sessionId: req.sessionId,
-				messages,
-				...hasMore ? { nextCursor: String(rows[rows.length - 1].seq) } : {}
+				messages: kept,
+				...hasOlder && kept.length > 0 ? { nextCursor: String(kept[0].seq) } : {}
+			};
+		},
+		toolBody(req) {
+			const rec = store.getSessionByAcpId(req.sessionId);
+			const empty = {
+				sessionId: req.sessionId,
+				toolCallId: req.toolCallId,
+				data: "",
+				totalBytes: 0
+			};
+			if (!rec) return empty;
+			const body = store.getToolBody(rec.channel, rec.thread, req.toolCallId);
+			if (body === void 0) return empty;
+			const buf = Buffer.from(body, "utf8");
+			const totalBytes = buf.length;
+			const offset = Math.min(req.offset, totalBytes);
+			const remaining = buf.subarray(offset);
+			let end = utf8Boundary(remaining, remaining.length);
+			let data = remaining.toString("utf8", 0, end);
+			while (end > 0 && encodedBytes(data) > REPLY_BUDGET) {
+				const factor = REPLY_BUDGET / encodedBytes(data);
+				const shrunk = Math.max(1, Math.floor(end * factor * .9));
+				end = utf8Boundary(remaining, Math.min(shrunk, end - 1));
+				data = remaining.toString("utf8", 0, end);
+			}
+			const nextOffset = offset + end;
+			return {
+				sessionId: req.sessionId,
+				toolCallId: req.toolCallId,
+				data,
+				totalBytes,
+				...nextOffset < totalBytes ? { nextOffset } : {}
 			};
 		}
 	};
@@ -84409,6 +84685,22 @@ var Daemon = class Daemon {
 	/** Persist one internal activity event (tool/reasoning). Ordered by row `seq`, so its
 	*  `ts` is just a wall-clock stamp for display — never used for replay/sorting. */
 	recordEvent(agentId, channel, thread, ev) {
+		if (ev.kind === "tool") {
+			if (ev.op === "insert") this.store.insertToolCall({
+				channel,
+				thread,
+				ts: String(Date.now()),
+				sender: agentId,
+				toolCallId: ev.toolCallId,
+				title: ev.text,
+				body: ev.body
+			});
+			else this.store.updateToolCall(channel, thread, ev.toolCallId, {
+				title: ev.text,
+				body: ev.body
+			});
+			return;
+		}
 		this.store.appendTranscript({
 			channel,
 			thread,