@alfe.ai/openclaw-chat 0.3.3 → 0.5.0

package/dist/plugin2.js

@@ -344,6 +344,31 @@ async function addMessage(sessionId, role, content, senderId, senderName) {
 	writeLocks.set(sessionId, next);
 	await next;
 }
+const MAX_ACTIVITY_PER_SESSION = 500;
+const MAX_ACTIVITY_THINKING_CHARS = 16e3;
+/**
+* Append a turn's terminalized activity records. Called ONCE per turn (from
+* the dispatch `finally`) — never per-delta: thinking deltas are
+* high-frequency and each save rewrites the whole session file.
+*/
+async function appendActivity(sessionId, entries) {
+	if (entries.length === 0) return;
+	const next = (writeLocks.get(sessionId) ?? Promise.resolve()).then(async () => {
+		const session = await getSession(sessionId);
+		if (!session) return;
+		const capped = entries.map((e) => e.kind === "thinking" && e.text.length > MAX_ACTIVITY_THINKING_CHARS ? {
+			...e,
+			text: e.text.slice(0, MAX_ACTIVITY_THINKING_CHARS)
+		} : e);
+		const combined = [...session.activity ?? [], ...capped];
+		session.activity = combined.length > MAX_ACTIVITY_PER_SESSION ? combined.slice(combined.length - MAX_ACTIVITY_PER_SESSION) : combined;
+		await saveSession(session);
+	}).finally(() => {
+		if (writeLocks.get(sessionId) === next) writeLocks.delete(sessionId);
+	});
+	writeLocks.set(sessionId, next);
+	await next;
+}
 async function listSessions(filters, limit = 50) {
 	await ensureDir();
 	let files;
@@ -848,6 +873,101 @@ function extractResultText(result) {
 	return parts.join("\n");
 }
 //#endregion
+//#region src/think-tags.ts
+/**
+* Inline `<think>` span handling for assistant text.
+*
+* Reasoning models routed through the AI proxy (DeepSeek `deepseek-*`,
+* Zhipu `glm-*`, …) emit their reasoning INLINE as `<think>…</think>` inside
+* the normal content stream instead of a structured thinking channel. The
+* openclaw-chat plugin (0.4.0+) diverts those spans into thinking activity
+* frames at the source; this relay-side copy is the DEFENSIVE layer for
+* agents still running older plugin versions — leaked reasoning is dropped
+* here, never synthesized into activity (that's the plugin's job).
+*
+* KEEP IN SYNC (byte-identical): this module exists at BOTH
+*   `services/chat/src/lib/think-tags.ts`        (relay, defensive layer)
+*   `packages/openclaw-chat/src/think-tags.ts`   (plugin, at-source divert)
+* The published plugin cannot import service internals, so the module is
+* duplicated, same as the ChatActivity shape.
+*
+* Known accepted limitation: a literal `<think>` in legitimate prose or a
+* code fence is treated as reasoning and stripped/diverted.
+*/
+const OPEN_TAG = "<think>";
+const CLOSE_TAG = "</think>";
+/**
+* Split CUMULATIVE assistant text into the user-visible part and the
+* reasoning part.
+*
+* Invariant (load-bearing): for successive cumulative snapshots that grow by
+* appending, `visible` is monotonically append-only — `visible(n)` is always
+* a prefix of `visible(n + 1)`. The delta relays slice by a `lastSentLength`
+* offset into this string; if `visible` ever shrank or rewrote earlier
+* characters, clients would receive corrupted deltas. This holds because the
+* scan is deterministic left-to-right and a trailing PARTIAL tag (any strict
+* prefix of the next expected tag, e.g. `"<thi"` or `"</th"`) is HELD BACK
+* from both outputs until later text disambiguates it.
+*/
+function splitThinkTags(cumulative) {
+	let visible = "";
+	let thinking = "";
+	let inThink = false;
+	let i = 0;
+	const n = cumulative.length;
+	while (i < n) {
+		const tag = inThink ? CLOSE_TAG : OPEN_TAG;
+		const idx = cumulative.indexOf(tag, i);
+		if (idx !== -1) {
+			const chunk = cumulative.slice(i, idx);
+			if (inThink) thinking += chunk;
+			else visible += chunk;
+			inThink = !inThink;
+			i = idx + tag.length;
+			continue;
+		}
+		let rest = cumulative.slice(i);
+		const held = trailingPartialTagLength(rest, tag);
+		if (held > 0) rest = rest.slice(0, rest.length - held);
+		if (inThink) thinking += rest;
+		else visible += rest;
+		break;
+	}
+	return {
+		visible,
+		thinking
+	};
+}
+/** Length of the longest strict prefix of `tag` that is a suffix of `text`. */
+function trailingPartialTagLength(text, tag) {
+	const max = Math.min(text.length, tag.length - 1);
+	for (let len = max; len > 0; len--) if (text.endsWith(tag.slice(0, len))) return len;
+	return 0;
+}
+/**
+* Strip `<think>…</think>` spans (and an unclosed trailing `<think>…`) from
+* FINAL text, then tidy the whitespace the spans leave behind.
+*
+* Idempotent — `stripThinkSpans(stripThinkSpans(x)) === stripThinkSpans(x)`.
+* New plugin + new relay both strip, so the second pass must be a no-op; the
+* fixpoint loop also covers pathological inputs where removing one span
+* makes the surrounding fragments form a new one.
+*
+* NOT for sliced/streaming paths — the trim + blank-line collapse breaks
+* prefix alignment with `lastSentLength`; those paths use
+* `splitThinkTags(...).visible` instead.
+*/
+function stripThinkSpans(text) {
+	let out = text;
+	let prev;
+	do {
+		prev = out;
+		out = out.replace(/<think>[\s\S]*?<\/think>/g, "");
+	} while (out !== prev);
+	out = out.replace(/<think>[\s\S]*$/, "");
+	return out.replace(/\n{3,}/g, "\n\n").trim();
+}
+//#endregion
 //#region src/plugin.ts
 /**
 * @alfe.ai/openclaw-chat — OpenClaw chat channel plugin.
@@ -913,7 +1033,7 @@ function asString(v) {
 * Returns null when there's nothing to forward.
 */
 function buildThinkingActivity(data) {
-	const text = asString(data.delta) ?? asString(data.text) ?? asString(data.content) ?? asString(data.message?.text);
+	const text = asString(data.delta) ?? asString(data.text) ?? asString(data.content) ?? asString(data.reasoning) ?? asString(data.reasoning_content) ?? asString(data.message?.text);
 	if (!text) return null;
 	return {
 		kind: "thinking",
@@ -922,6 +1042,34 @@ function buildThinkingActivity(data) {
 	};
 }
 /**
+* Join the text parts of an assistant-stream event's content array.
+* Assistant `evt.data` is a message object whose `content` is an array of
+* typed parts; deltas are CUMULATIVE snapshots (the relay length-compares
+* them — see adapter.ts's lastSentLength slicing). Non-array/absent content
+* yields '' (nothing to divert).
+*/
+function joinAssistantText(data) {
+	const content = data.content;
+	if (!Array.isArray(content)) return "";
+	return content.filter((c) => typeof c === "object" && c !== null && c.type === "text" && typeof c.text === "string").map((c) => c.text).join("");
+}
+/**
+* Rebuild an assistant event's message with its text parts replaced by one
+* `{type:'text', text: visible}` part. Non-text parts are preserved — the
+* relay's consumers (adapter/inject/voice-bridge) only join text parts, so
+* relative ordering against non-text items is not load-bearing.
+*/
+function rewriteAssistantText(data, visible) {
+	const nonText = (Array.isArray(data.content) ? data.content : []).filter((c) => !(typeof c === "object" && c !== null && c.type === "text"));
+	return {
+		...data,
+		content: [...nonText, {
+			type: "text",
+			text: visible
+		}]
+	};
+}
+/**
 * Extract structured tool status from an OpenClaw `tool`-stream event.
 * We send the emoji-free raw `name` plus a lifecycle `status` and let the
 * web render the `🛠️ <Label>: <summary> ✓/✗` row — never OpenClaw's raw
@@ -1038,6 +1186,37 @@ function buildA2ACompletePayload(params) {
 	};
 }
 let dispatchInbound = null;
+let abortEmbeddedAgentRun = null;
+let resolveActiveRunSessionId = null;
+let resolveRouteEnvelope = null;
+/**
+* Load the OpenClaw SDK surfaces from a single resolver anchor. Returns true
+* once the critical `dispatchInboundDirectDmWithRuntime` is resolved. The abort
+* primitives + route resolver are best-effort — an older openclaw without them
+* degrades `chat.abort` to a logged no-op (Stop still seals the UI) rather than
+* a hard failure.
+*/
+function loadOpenClawSdk(req, log, anchor) {
+	let resolvedDispatch = false;
+	try {
+		const channelInbound = req("openclaw/plugin-sdk/channel-inbound");
+		if (channelInbound.dispatchInboundDirectDmWithRuntime) {
+			dispatchInbound = channelInbound.dispatchInboundDirectDmWithRuntime;
+			resolvedDispatch = true;
+		}
+	} catch {}
+	try {
+		const harness = req("openclaw/plugin-sdk/agent-harness");
+		if (harness.abortEmbeddedAgentRun) abortEmbeddedAgentRun = harness.abortEmbeddedAgentRun;
+		if (harness.resolveActiveEmbeddedRunSessionId) resolveActiveRunSessionId = harness.resolveActiveEmbeddedRunSessionId;
+	} catch {}
+	try {
+		const envelope = req("openclaw/plugin-sdk/inbound-envelope");
+		if (envelope.resolveInboundRouteEnvelopeBuilderWithRuntime) resolveRouteEnvelope = envelope.resolveInboundRouteEnvelopeBuilderWithRuntime;
+	} catch {}
+	if (resolvedDispatch) log.info(`Resolved OpenClaw SDK from ${anchor} (hard-abort=${abortEmbeddedAgentRun && resolveActiveRunSessionId ? "available" : "unavailable"})`);
+	return resolvedDispatch;
+}
 /**
 * Resolve OpenClaw SDK functions from the running process.
 *
@@ -1049,21 +1228,11 @@ let dispatchInbound = null;
 function resolveOpenClawSdk(log) {
 	const anchors = [require.main?.filename, process.argv[1]].filter(Boolean);
 	for (const anchor of anchors) try {
-		const channelInbound = createRequire(anchor)("openclaw/plugin-sdk/channel-inbound");
-		if (channelInbound.dispatchInboundDirectDmWithRuntime) {
-			dispatchInbound = channelInbound.dispatchInboundDirectDmWithRuntime;
-			log.info(`Resolved OpenClaw SDK from ${anchor}`);
-			return;
-		}
+		if (loadOpenClawSdk(createRequire(anchor), log, anchor)) return;
 	} catch {}
 	try {
 		const derivedPath = join(resolve(dirname(process.execPath), ".."), "lib", "node_modules", "openclaw", "package.json");
-		const channelInbound = createRequire(derivedPath)("openclaw/plugin-sdk/channel-inbound");
-		if (channelInbound.dispatchInboundDirectDmWithRuntime) {
-			dispatchInbound = channelInbound.dispatchInboundDirectDmWithRuntime;
-			log.info(`Resolved OpenClaw SDK from ${derivedPath}`);
-			return;
-		}
+		if (loadOpenClawSdk(createRequire(derivedPath), log, derivedPath)) return;
 	} catch {}
 	log.warn("OpenClaw SDK not resolvable — chat dispatch will not work");
 }
@@ -1140,11 +1309,111 @@ async function downloadAttachments(attachments, log) {
 	}
 	return results;
 }
-let agentTurnQueue = Promise.resolve();
-function enqueueAgentTurn(task) {
-	const run = agentTurnQueue.then(task, task);
-	agentTurnQueue = run.then(() => void 0, () => void 0);
-	return run;
+let agentTurnBacklog = [];
+let agentTurnDraining = false;
+function enqueueAgentTurn(task, opts) {
+	return new Promise((resolve, reject) => {
+		const entry = {
+			run: task,
+			coalesceKey: opts?.coalesceKey,
+			onSuperseded: opts?.onSuperseded ?? (() => void 0),
+			resolve,
+			reject
+		};
+		if (entry.coalesceKey) {
+			const survivors = [];
+			for (const queued of agentTurnBacklog) if (queued.coalesceKey === entry.coalesceKey) {
+				try {
+					queued.onSuperseded();
+				} catch {}
+				queued.resolve();
+			} else survivors.push(queued);
+			agentTurnBacklog = survivors;
+		}
+		agentTurnBacklog.push(entry);
+		drainAgentTurns();
+	});
+}
+async function drainAgentTurns() {
+	if (agentTurnDraining) return;
+	agentTurnDraining = true;
+	try {
+		while (agentTurnBacklog.length > 0) {
+			const entry = agentTurnBacklog.shift();
+			if (!entry) break;
+			try {
+				await entry.run();
+				entry.resolve();
+			} catch (err) {
+				entry.reject(err);
+			}
+		}
+	} finally {
+		agentTurnDraining = false;
+	}
+}
+/**
+* Test-only: reset the agent-turn backlog between unit tests. Not used at
+* runtime (the backlog lives for the process lifetime of one daemon).
+*/
+function __resetAgentTurnQueueForTest() {
+	agentTurnBacklog = [];
+	agentTurnDraining = false;
+}
+/** Test-only accessor for the coalescing queue (see __tests__/queue.test.ts). */
+const __agentTurnQueueForTest = {
+	enqueue: enqueueAgentTurn,
+	backlogLength: () => agentTurnBacklog.length
+};
+let activeRun = null;
+/** Test-only: set/clear the active-run ref for handleChatAbort unit tests. */
+function __setActiveRunForTest(ref) {
+	activeRun = ref;
+}
+/**
+* Ordered session keys to try when aborting for `abortSessionKey`. Pure, so it
+* unit-tests without the OpenClaw SDK. The resolved route key (what the run
+* registered under) is preferred; the raw request key is a best-effort
+* fallback. An abort with NO sessionKey targets the single active run. A
+* sessionKey that does NOT match the running turn yields no candidates — we
+* never abort another session's run on a shared daemon.
+*/
+function resolveAbortTargetKeys(active, abortSessionKey) {
+	const keys = [];
+	if (active && (!abortSessionKey || active.requestSessionKey === abortSessionKey)) {
+		if (active.routeSessionKey) keys.push(active.routeSessionKey);
+		if (!keys.includes(active.requestSessionKey)) keys.push(active.requestSessionKey);
+	} else if (abortSessionKey) keys.push(abortSessionKey);
+	return keys;
+}
+/**
+* `chat.abort` handler — genuinely cancels the RUNNING turn on the daemon.
+*
+* Invoked OUT-OF-BAND (never through the serialised agent-turn queue) so it
+* executes immediately while a turn is mid-flight. Resolves the live run's
+* sessionId from the target session key and fires the run handle's
+* AbortController via `abortEmbeddedAgentRun`. The in-flight dispatch then
+* settles (AbortError), so `handleAgentRequest` sends its RPC response and the
+* chat service seals the UI. When the abort primitives are unavailable (older
+* openclaw), this degrades to a logged no-op: the UI is still sealed by the
+* chat service's optimistic idle broadcast, but the turn completes server-side.
+*/
+function handleChatAbort(request, log) {
+	const { sessionKey } = request.params;
+	const targetKeys = resolveAbortTargetKeys(activeRun, sessionKey);
+	let aborted = false;
+	if (abortEmbeddedAgentRun && resolveActiveRunSessionId) {
+		for (const key of targetKeys) {
+			const sessionId = resolveActiveRunSessionId(key);
+			if (sessionId && abortEmbeddedAgentRun(sessionId)) {
+				aborted = true;
+				log.info(`chat.abort: hard-aborted running turn (sessionId=${sessionId}, key=${key})`);
+				break;
+			}
+		}
+		if (!aborted) log.info(`chat.abort: no active run to abort (candidates=${String(targetKeys.length)})`);
+	} else log.warn("chat.abort: OpenClaw abort primitives unavailable — cannot hard-abort the running turn");
+	chatClient?.sendResponse(request.id, true, { aborted });
 }
 async function handleAgentRequest(request, log) {
 	const runtime = pluginRuntime;
@@ -1171,6 +1440,43 @@ async function handleAgentRequest(request, log) {
 		runId: null,
 		sessionKey: null
 	};
+	let lastThinkingLen = 0;
+	const turnThinking = {
+		text: "",
+		ts: 0
+	};
+	const turnTools = /* @__PURE__ */ new Map();
+	const recordThinking = (text, ts) => {
+		if (!turnThinking.text) turnThinking.ts = ts;
+		turnThinking.text += text;
+	};
+	const recordTool = (activity, ts) => {
+		const prev = turnTools.get(activity.toolCallId);
+		turnTools.set(activity.toolCallId, {
+			kind: "tool",
+			toolCallId: activity.toolCallId,
+			name: activity.name,
+			status: activity.status === "running" ? prev?.status ?? "interrupted" : activity.status,
+			...activity.summary ?? prev?.summary ? { summary: activity.summary ?? prev?.summary } : {},
+			...prev?.argsText ?? activity.argsText ? { argsText: prev?.argsText ?? activity.argsText } : {},
+			...activity.resultText ?? prev?.resultText ? { resultText: activity.resultText ?? prev?.resultText } : {},
+			...(activity.isError ?? prev?.isError) !== void 0 ? { isError: activity.isError ?? prev?.isError } : {},
+			...(activity.durationMs ?? prev?.durationMs) !== void 0 ? { durationMs: activity.durationMs ?? prev?.durationMs } : {},
+			...activity.truncated ?? prev?.truncated ? { truncated: activity.truncated ?? prev?.truncated } : {},
+			ts: prev?.ts ?? ts
+		});
+	};
+	const flushTurnActivity = async () => {
+		const entries = [];
+		if (turnThinking.text) entries.push({
+			kind: "thinking",
+			text: turnThinking.text,
+			ts: turnThinking.ts
+		});
+		for (const tool of turnTools.values()) entries.push(tool);
+		entries.sort((a, b) => a.ts - b.ts);
+		await appendActivity(sessionId, entries);
+	};
 	const UPDATE_THROTTLE_MS = 250;
 	const pendingUpdates = /* @__PURE__ */ new Map();
 	const flushToolUpdate = (toolCallId) => {
@@ -1187,33 +1493,58 @@ async function handleAgentRequest(request, log) {
 	const unsubscribe = runtime.events.onAgentEvent((evt) => {
 		if (!admitAgentEvent(runGate, evt)) return;
 		if (evt.stream === "assistant") {
+			const raw = joinAssistantText(evt.data);
+			const { visible, thinking } = splitThinkTags(raw);
+			if (thinking.length > lastThinkingLen) {
+				const thinkingDelta = thinking.slice(lastThinkingLen);
+				chatClient?.sendEvent("chat-activity", {
+					runId: evt.runId,
+					sessionKey: legacySessionKey,
+					seq: evt.seq,
+					state: "activity",
+					activity: {
+						kind: "thinking",
+						text: thinkingDelta,
+						delta: true,
+						ts: evt.ts,
+						seq: evt.seq
+					}
+				});
+				recordThinking(thinkingDelta, evt.ts);
+				lastThinkingLen = thinking.length;
+			}
+			const message = visible === raw && thinking.length === 0 ? evt.data : rewriteAssistantText(evt.data, visible);
 			chatClient?.sendEvent("chat", {
 				runId: evt.runId,
 				sessionKey: legacySessionKey,
 				seq: evt.seq,
 				state: "delta",
-				message: evt.data
+				message
 			});
 			return;
 		}
 		if (evt.stream === "thinking") {
 			const activity = buildThinkingActivity(evt.data);
-			if (activity) chatClient?.sendEvent("chat-activity", {
-				runId: evt.runId,
-				sessionKey: legacySessionKey,
-				seq: evt.seq,
-				state: "activity",
-				activity: {
-					...activity,
-					ts: evt.ts,
-					seq: evt.seq
-				}
-			});
+			if (activity) {
+				chatClient?.sendEvent("chat-activity", {
+					runId: evt.runId,
+					sessionKey: legacySessionKey,
+					seq: evt.seq,
+					state: "activity",
+					activity: {
+						...activity,
+						ts: evt.ts,
+						seq: evt.seq
+					}
+				});
+				if (activity.kind === "thinking") recordThinking(activity.text, evt.ts);
+			}
 			return;
 		}
 		if (evt.stream === "tool") {
 			const activity = buildToolActivity(evt.data);
 			if (activity?.kind !== "tool") return;
+			recordTool(activity, evt.ts);
 			const toolCallId = activity.toolCallId;
 			const send = () => {
 				chatClient?.sendEvent("chat-activity", {
@@ -1263,19 +1594,37 @@ async function handleAgentRequest(request, log) {
 		const conversationLabel = conversationType === "group" ? shortConvId ? `[${channelLabel}] Group (${shortConvId})` : `[${channelLabel}] Group` : shortConvId ? `[${channelLabel}] ${userLabel} (${shortConvId})` : `[${channelLabel}] ${userLabel}`;
 		let a2aResponseBuffer = "";
 		if (isA2A) resetA2AEndSignal();
+		const peer = conversationType === "group" ? {
+			kind: "group",
+			id: conversationId ?? senderId
+		} : {
+			kind: "direct",
+			id: conversationId ? `${senderId}:conv:${conversationId}` : senderId
+		};
+		let routeSessionKey = null;
+		if (resolveRouteEnvelope) try {
+			routeSessionKey = resolveRouteEnvelope({
+				cfg,
+				channel: "alfe",
+				accountId: "default",
+				peer,
+				runtime: runtime.channel,
+				sessionStore: cfg.session?.store
+			}).route.sessionKey;
+		} catch (err) {
+			log.debug(`Route precompute failed (abort will use raw key): ${err instanceof Error ? err.message : String(err)}`);
+		}
+		activeRun = {
+			requestSessionKey: legacySessionKey,
+			routeSessionKey
+		};
 		runGate.sessionKey = (await dispatchInbound({
 			cfg,
 			runtime: { channel: runtime.channel },
 			channel: "alfe",
 			channelLabel,
 			accountId: "default",
-			peer: conversationType === "group" ? {
-				kind: "group",
-				id: conversationId ?? senderId
-			} : {
-				kind: "direct",
-				id: conversationId ? `${senderId}:conv:${conversationId}` : senderId
-			},
+			peer,
 			senderId,
 			senderAddress: senderId,
 			recipientAddress: "agent",
@@ -1309,10 +1658,10 @@ async function handleAgentRequest(request, log) {
 				} : {}
 			},
 			deliver: async (payload) => {
-				const responseText = stripLeakedToolSummary(payload.text ?? "");
+				const responseText = stripLeakedToolSummary(stripThinkSpans(payload.text ?? ""));
 				const mediaUrls = [...payload.mediaUrl ? [payload.mediaUrl] : [], ...payload.mediaUrls ?? []];
 				await addMessage(sessionId, "assistant", responseText);
-				if (isA2A) a2aResponseBuffer += responseText;
+				if (isA2A) a2aResponseBuffer += (a2aResponseBuffer && responseText ? "\n\n" : "") + responseText;
 				chatClient?.notify("agent-message", {
 					conversationId: conversationId ?? legacySessionKey,
 					text: responseText,
@@ -1344,8 +1693,14 @@ async function handleAgentRequest(request, log) {
 		log.error(`Agent dispatch failed: ${errMsg}`);
 		chatClient?.sendResponse(request.id, false, { message: errMsg });
 	} finally {
+		activeRun = null;
 		unsubscribe();
 		clearAllToolUpdates();
+		try {
+			await flushTurnActivity();
+		} catch (err) {
+			log.error(`Activity persistence failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
 		if (isA2A) disarmA2AEndSignal();
 	}
 }
@@ -1371,14 +1726,16 @@ async function handleSessionsGet(request, log) {
 		if (!session) {
 			chatClient?.sendResponse(request.id, true, {
 				ok: false,
-				error: "Session not found"
+				error: "Session not found",
+				messages: []
 			});
 			return;
 		}
 		if (params.userId && session.userId && session.userId !== params.userId) {
 			chatClient?.sendResponse(request.id, true, {
 				ok: false,
-				error: "Session not found"
+				error: "Session not found",
+				messages: []
 			});
 			return;
 		}
@@ -1392,7 +1749,8 @@ async function handleSessionsGet(request, log) {
 				role: m.role,
 				content: m.content,
 				timestamp: m.timestamp
-			}))
+			})),
+			activity: (session.activity ?? []).map((a) => ({ ...a }))
 		});
 	} catch (err) {
 		const errMsg = err instanceof Error ? err.message : String(err);
@@ -1444,7 +1802,20 @@ const plugin = {
 							apiKey,
 							onRequest: (request) => {
 								const handle = async () => {
-									if (request.method === "agent") await enqueueAgentTurn(() => handleAgentRequest(request, log));
+									if (request.method === "agent") {
+										const params = request.params;
+										const coalesceKey = params.coalesce === "replace" && typeof params.sessionKey === "string" ? params.sessionKey : void 0;
+										await enqueueAgentTurn(() => handleAgentRequest(request, log), coalesceKey ? {
+											coalesceKey,
+											onSuperseded: () => {
+												log.info(`Agent turn superseded before start (coalesce=replace): ${coalesceKey}`);
+												chatClient?.sendResponse(request.id, true, {
+													superseded: true,
+													sessionKey: coalesceKey
+												});
+											}
+										} : void 0);
+									} else if (request.method === "chat.abort") handleChatAbort(request, log);
 									else if (request.method === "sessions.list") await handleSessionsList(request, log);
 									else if (request.method === "sessions.get") await handleSessionsGet(request, log);
 									else chatClient?.sendResponse(request.id, false, { message: `Unknown method: ${request.method}` });
@@ -1500,11 +1871,13 @@ const plugin = {
 				const session = await getSession(params.sessionId);
 				if (!session) return {
 					ok: false,
-					error: "Session not found"
+					error: "Session not found",
+					messages: []
 				};
 				if (params.userId && session.userId && session.userId !== params.userId) return {
 					ok: false,
-					error: "Session not found"
+					error: "Session not found",
+					messages: []
 				};
 				return {
 					sessionId: session.sessionId,
@@ -1516,7 +1889,8 @@ const plugin = {
 						role: m.role,
 						content: m.content,
 						timestamp: m.timestamp
-					}))
+					})),
+					activity: (session.activity ?? []).map((a) => ({ ...a }))
 				};
 			});
 			gw.__alfeChatGatewayMethodsRegistered = true;
@@ -1574,4 +1948,4 @@ const plugin = {
 	}
 };
 //#endregion
-export { stripLeakedToolSummary as a, plugin as i, buildA2ACompletePayload as n, createAlfeChannelPlugin as o, buildToolActivity as r, admitAgentEvent as t };
+export { buildA2ACompletePayload as a, plugin as c, stripLeakedToolSummary as d, createAlfeChannelPlugin as f, admitAgentEvent as i, resolveAbortTargetKeys as l, __resetAgentTurnQueueForTest as n, buildToolActivity as o, __setActiveRunForTest as r, joinAssistantText as s, __agentTurnQueueForTest as t, rewriteAssistantText as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/openclaw-chat",
-  "version": "0.3.3",
+  "version": "0.5.0",
   "description": "OpenClaw chat plugin for Alfe — web widget and mobile app channels",
   "type": "module",
   "main": "./dist/plugin.js",