@openclaw/clickclack 2026.7.1-beta.1 → 2026.7.1-beta.4

package/dist/api.js

@@ -1,2 +1,2 @@
-import { a as getClickClackRuntime, c as DEFAULT_ACCOUNT_ID, d as resolveClickClackAccount, f as resolveDefaultClickClackAccountId, i as createClickClackClient, l as listClickClackAccountIds, n as buildClickClackTarget, o as setClickClackRuntime, r as parseClickClackTarget, s as clickClackConfigSchema, t as clickClackPlugin, u as listEnabledClickClackAccounts } from "./channel-OEzEDUUh.js";
+import { a as getClickClackRuntime, c as DEFAULT_ACCOUNT_ID, d as resolveClickClackAccount, f as resolveDefaultClickClackAccountId, i as createClickClackClient, l as listClickClackAccountIds, n as buildClickClackTarget, o as setClickClackRuntime, r as parseClickClackTarget, s as clickClackConfigSchema, t as clickClackPlugin, u as listEnabledClickClackAccounts } from "./channel-1ZnJZTPl.js";
 export { DEFAULT_ACCOUNT_ID, buildClickClackTarget, clickClackConfigSchema, clickClackPlugin, createClickClackClient, getClickClackRuntime, listClickClackAccountIds, listEnabledClickClackAccounts, parseClickClackTarget, resolveClickClackAccount, resolveDefaultClickClackAccountId, setClickClackRuntime };

package/dist/{channel-OEzEDUUh.js → channel-1ZnJZTPl.js}

@@ -6,15 +6,17 @@ import { resolveDefaultSecretProviderAlias } from "openclaw/plugin-sdk/provider-
 import { buildSecretInputSchema, normalizeResolvedSecretInputString, normalizeSecretInputString, resolveSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { buildChannelOutboundSessionRoute, buildThreadAwareOutboundSessionRoute, createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
-import { createMessageReceiptFromOutboundResults, defineChannelMessageAdapter } from "openclaw/plugin-sdk/channel-outbound";
+import { buildChannelProgressDraftLine, createMessageReceiptFromOutboundResults, defineChannelMessageAdapter } from "openclaw/plugin-sdk/channel-outbound";
 import { getChatChannelMeta } from "openclaw/plugin-sdk/channel-plugin-common";
 import { createComputedAccountStatusAdapter, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";
 import { buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
 import { z } from "zod";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { resolveStableChannelMessageIngress } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
 import { readProviderJsonResponse, readResponseTextLimited } from "openclaw/plugin-sdk/provider-http";
 import { WebSocket } from "ws";
+import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 //#region extensions/clickclack/src/accounts.ts
 /**
 * Resolves ClickClack account configuration from root channel config, named
@@ -99,6 +101,7 @@ function resolveClickClackAccount(params) {
 			min: MIN_RECONNECT_MS,
 			max: MAX_RECONNECT_MS
 		}),
+		agentActivity: merged.agentActivity === true,
 		config: {
 			...merged,
 			allowFrom: merged.allowFrom ?? ["*"]
@@ -135,7 +138,8 @@ const ClickClackAccountConfigSchema = z.object({
 	toolsAllow: z.array(z.string()).optional(),
 	defaultTo: z.string().optional(),
 	allowFrom: z.array(z.string()).optional(),
-	reconnectMs: z.number().int().min(100).max(6e4).optional()
+	reconnectMs: z.number().int().min(100).max(6e4).optional(),
+	agentActivity: z.boolean().optional()
 }).strict();
 /**
 * Config schema exported to core so `openclaw doctor` and config validation
@@ -213,6 +217,18 @@ async function resolveClickClackInboundAccess(params) {
 * Thin ClickClack REST/websocket client used by gateway, resolver, and outbound
 * delivery code.
 */
+/**
+* Serializes optional provenance into the wire fields. Unknown JSON fields
+* are ignored by servers without the provenance columns, so these are safe
+* to send unconditionally when present.
+*/
+function provenanceFields(provenance) {
+	const fields = {};
+	if (provenance?.model?.trim()) fields.author_model = provenance.model.trim();
+	if (provenance?.thinking?.trim()) fields.author_thinking = provenance.thinking.trim();
+	if (provenance?.runtime?.trim()) fields.author_runtime = provenance.runtime.trim();
+	return fields;
+}
 const CLICKCLACK_ERROR_BODY_LIMIT_BYTES = 8 * 1024;
 /**
 * Creates a typed client for the ClickClack API using bearer-token auth.
@@ -255,16 +271,23 @@ function createClickClackClient(options) {
 			return (await request(`/api/dms/${encodeURIComponent(conversationId)}/messages?after_seq=${afterSeq}&limit=${limit}`)).messages;
 		},
 		thread: async (messageId) => await request(`/api/messages/${encodeURIComponent(messageId)}/thread`),
-		createChannelMessage: async (channelId, body) => {
+		createChannelMessage: async (channelId, body, opts) => {
 			return (await request(`/api/channels/${encodeURIComponent(channelId)}/messages`, {
 				method: "POST",
-				body: JSON.stringify({ body })
+				body: JSON.stringify({
+					body,
+					...opts?.quotedMessageId ? { quoted_message_id: opts.quotedMessageId } : {},
+					...provenanceFields(opts?.provenance)
+				})
 			})).message;
 		},
-		createThreadReply: async (messageId, body) => {
+		createThreadReply: async (messageId, body, opts) => {
 			return (await request(`/api/messages/${encodeURIComponent(messageId)}/thread/replies`, {
 				method: "POST",
-				body: JSON.stringify({ body })
+				body: JSON.stringify({
+					body,
+					...provenanceFields(opts?.provenance)
+				})
 			})).message;
 		},
 		createDirectConversation: async (workspaceId, memberIds) => {
@@ -276,12 +299,39 @@ function createClickClackClient(options) {
 				})
 			})).conversation;
 		},
-		createDirectMessage: async (conversationId, body) => {
-			return (await request(`/api/dms/${encodeURIComponent(conversationId)}/messages`, {
+		/**
+		* POSTs a durable agent activity row (agent_commentary / agent_tool)
+		* through the normal message create path. Requires a bot token carrying
+		* the agent_activity:write scope on the ClickClack side.
+		*/
+		createActivityMessage: async (params) => {
+			if (!params.channelId && !params.conversationId) throw new Error("createActivityMessage requires a channelId or conversationId");
+			return (await request(params.channelId ? `/api/channels/${encodeURIComponent(params.channelId)}/messages` : `/api/dms/${encodeURIComponent(params.conversationId ?? "")}/messages`, {
 				method: "POST",
+				body: JSON.stringify({
+					body: params.body,
+					kind: params.kind,
+					turn_id: params.turnId,
+					...provenanceFields(params.provenance)
+				})
+			})).message;
+		},
+		/** PATCHes the body of an existing message (activity row coalescing). */
+		updateMessageBody: async (messageId, body) => {
+			return (await request(`/api/messages/${encodeURIComponent(messageId)}`, {
+				method: "PATCH",
 				body: JSON.stringify({ body })
 			})).message;
 		},
+		createDirectMessage: async (conversationId, body, opts) => {
+			return (await request(`/api/dms/${encodeURIComponent(conversationId)}/messages`, {
+				method: "POST",
+				body: JSON.stringify({
+					body,
+					...opts?.quotedMessageId ? { quoted_message_id: opts.quotedMessageId } : {}
+				})
+			})).message;
+		},
 		events: async (workspaceId, afterCursor) => {
 			const query = new URLSearchParams({ workspace_id: workspaceId });
 			if (afterCursor) query.set("after_cursor", afterCursor);
@@ -297,6 +347,201 @@ function createClickClackClient(options) {
 	};
 }
 //#endregion
+//#region extensions/clickclack/src/activity.ts
+/**
+* Publishes agent activity (streamed commentary + tool progress) into
+* ClickClack as durable `agent_commentary` / `agent_tool` message rows,
+* coalesced so one logical step becomes one row instead of a row per frame.
+*
+* Ported from the clickglass agent-bridge sidecar, adapted from gateway
+* websocket frames to the in-process `replyOptions.onItemEvent` seam:
+*
+* - Commentary/reasoning arrives as cumulative text snapshots per item id.
+*   Each segment becomes one durable row: POSTed when the segment starts
+*   streaming and PATCHed (debounced) as the snapshot grows, so prose
+*   interleaves chronologically with tool rows.
+* - Tool/step items can emit several frames (start/update/complete) for the
+*   same call, sometimes with lane-prefixed ids (`tool:X`, `command:X`).
+*   Normalize the prefix away to one key per call, POST one row on the first
+*   frame, and PATCH it when a later frame carries a strictly longer body.
+*/
+/** Debounce window for PATCHing streaming commentary snapshots. */
+const CLICKCLACK_COMMENTARY_FLUSH_MS = 700;
+/** Item kinds rendered as agent_tool rows; everything else is commentary. */
+const TOOL_ITEM_KINDS = /* @__PURE__ */ new Set([
+	"tool",
+	"command",
+	"command_output",
+	"patch",
+	"search",
+	"api"
+]);
+/** Item kinds that never become durable rows (ephemeral or plumbing lanes). */
+const SKIPPED_ITEM_KINDS = /* @__PURE__ */ new Set(["lifecycle"]);
+/** Item kinds emitted as cumulative commentary snapshots. */
+const STREAMING_COMMENTARY_ITEM_KINDS = /* @__PURE__ */ new Set([
+	"preamble",
+	"commentary",
+	"analysis",
+	"thinking",
+	"reasoning"
+]);
+/** Provider-specific reasoning lanes normalized into one ClickClack label. */
+const THINKING_ITEM_KINDS = /* @__PURE__ */ new Set([
+	"analysis",
+	"thinking",
+	"reasoning"
+]);
+function normalizedItemKind(payload) {
+	return payload.kind?.trim().toLowerCase() ?? "";
+}
+function commentaryBody(payload) {
+	const text = payload.progressText?.trim() || payload.summary?.trim() || payload.meta?.trim() || "";
+	if (!text) return "";
+	const kind = normalizedItemKind(payload);
+	if (THINKING_ITEM_KINDS.has(kind)) return `**Thinking**\n\n${text}`;
+	return text;
+}
+function activityBody(payload) {
+	const line = buildChannelProgressDraftLine({
+		event: "item",
+		itemId: payload.itemId,
+		toolCallId: payload.toolCallId,
+		itemKind: payload.kind,
+		title: payload.title,
+		name: payload.name,
+		phase: payload.phase,
+		status: payload.status,
+		summary: payload.summary,
+		progressText: payload.progressText,
+		meta: payload.meta
+	})?.text?.trim();
+	if (line) return line;
+	const head = payload.name?.trim() || payload.title?.trim();
+	const text = payload.progressText?.trim() || payload.summary?.trim();
+	if (head && text) return `**${head}**\n\n${text}`;
+	if (text) return text;
+	if (head) return head;
+	return payload.status?.trim() || payload.kind?.trim() || "";
+}
+/**
+* Creates a per-turn activity publisher. Publishing is best-effort: transport
+* failures are reported through `onError` and never interrupt the reply turn.
+*/
+function createClickClackActivityPublisher(params) {
+	const flushMs = params.flushMs ?? CLICKCLACK_COMMENTARY_FLUSH_MS;
+	const commentaryByItem = /* @__PURE__ */ new Map();
+	const toolRows = /* @__PURE__ */ new Map();
+	let provenance;
+	let chain = Promise.resolve();
+	const enqueue = (work) => {
+		chain = chain.then(work).catch((error) => {
+			params.onError?.(error);
+		});
+		return chain;
+	};
+	const postRow = (kind, body) => params.client.createActivityMessage({
+		channelId: params.target.channelId,
+		conversationId: params.target.conversationId,
+		body,
+		kind,
+		turnId: params.turnId,
+		provenance
+	});
+	const flushCommentary = (segmentKey) => {
+		const segment = commentaryByItem.get(segmentKey);
+		if (!segment) return Promise.resolve();
+		if (segment.timer) {
+			clearTimeout(segment.timer);
+			segment.timer = void 0;
+		}
+		if (!segment.dirty || !segment.body.trim()) return Promise.resolve();
+		segment.dirty = false;
+		const body = segment.body;
+		return enqueue(async () => {
+			if (segment.messageId) {
+				await params.client.updateMessageBody(segment.messageId, body);
+				return;
+			}
+			const posted = await postRow("agent_commentary", body);
+			segment.messageId = posted.id;
+		});
+	};
+	const flushAllCommentary = () => {
+		const flushes = [...commentaryByItem.keys()].map((key) => flushCommentary(key));
+		return Promise.all(flushes).then(() => void 0);
+	};
+	const handleCommentary = (payload) => {
+		const body = commentaryBody(payload);
+		if (!body.trim()) return;
+		const key = payload.itemId?.trim() || "turn";
+		let segment = commentaryByItem.get(key);
+		if (!segment) {
+			segment = {
+				body: "",
+				dirty: false
+			};
+			commentaryByItem.set(key, segment);
+		}
+		if (body.length < segment.body.length || body === segment.body) return;
+		segment.body = body;
+		segment.dirty = true;
+		if (!segment.timer) segment.timer = setTimeout(() => {
+			segment.timer = void 0;
+			flushCommentary(key);
+		}, flushMs);
+	};
+	const toolRowKey = (payload) => {
+		const toolCallId = payload.toolCallId?.trim();
+		if (toolCallId) return toolCallId;
+		return (payload.itemId?.trim() ?? "").replace(/^(tool|command):/, "");
+	};
+	const handleDiscreteItem = (payload) => {
+		const body = activityBody(payload);
+		if (!body) return;
+		const kind = TOOL_ITEM_KINDS.has(payload.kind?.trim().toLowerCase() ?? "") ? "agent_tool" : "agent_commentary";
+		flushAllCommentary();
+		const key = `${kind}:${toolRowKey(payload)}`;
+		const existing = toolRows.get(key);
+		if (!existing || !toolRowKey(payload)) {
+			const row = { body };
+			if (toolRowKey(payload)) toolRows.set(key, row);
+			enqueue(async () => {
+				const posted = await postRow(kind, row.body);
+				row.messageId = posted.id;
+				row.sentBody = row.body;
+			});
+			return;
+		}
+		if (body.length <= existing.body.length) return;
+		existing.body = body;
+		enqueue(async () => {
+			if (existing.messageId && existing.body !== existing.sentBody) {
+				await params.client.updateMessageBody(existing.messageId, existing.body);
+				existing.sentBody = existing.body;
+			}
+		});
+	};
+	return {
+		onItemEvent: (payload) => {
+			const kind = normalizedItemKind(payload);
+			if (STREAMING_COMMENTARY_ITEM_KINDS.has(kind)) {
+				handleCommentary(payload);
+				return;
+			}
+			if (SKIPPED_ITEM_KINDS.has(kind)) return;
+			handleDiscreteItem(payload);
+		},
+		setProvenance: (next) => {
+			provenance = next;
+		},
+		finalize: async () => {
+			await flushAllCommentary();
+			await chain;
+		}
+	};
+}
+//#endregion
 //#region extensions/clickclack/src/resolve.ts
 /**
 * Resolves a workspace slug/name/id from config to a ClickClack workspace id.
@@ -384,9 +629,9 @@ async function sendClickClackText(params) {
 	const parsed = parseClickClackTarget(params.to);
 	const explicitThreadId = params.threadId == null ? "" : String(params.threadId);
 	const replyToId = params.replyToId == null ? "" : String(params.replyToId);
-	if (explicitThreadId || replyToId || parsed.kind === "thread") {
-		const rootId = explicitThreadId || replyToId || parsed.id;
-		const message = await client.createThreadReply(rootId, params.text);
+	if (explicitThreadId || parsed.kind === "thread") {
+		const rootId = explicitThreadId || parsed.id;
+		const message = await client.createThreadReply(rootId, params.text, { provenance: params.provenance });
 		return {
 			to: params.to,
 			messageId: message.id
@@ -394,14 +639,17 @@ async function sendClickClackText(params) {
 	}
 	if (parsed.kind === "dm") {
 		const dm = await client.createDirectConversation(workspaceId, [parsed.id]);
-		const message = await client.createDirectMessage(dm.id, params.text);
+		const message = await client.createDirectMessage(dm.id, params.text, { quotedMessageId: replyToId || void 0 });
 		return {
 			to: params.to,
 			messageId: message.id
 		};
 	}
 	const channelId = await resolveChannelId(client, workspaceId, parsed.id);
-	const message = await client.createChannelMessage(channelId, params.text);
+	const message = await client.createChannelMessage(channelId, params.text, {
+		provenance: params.provenance,
+		quotedMessageId: replyToId || void 0
+	});
 	return {
 		to: params.to,
 		messageId: message.id
@@ -421,20 +669,36 @@ function resolveAccountAgentRoute(params) {
 			id: params.target
 		}
 	});
-	const agentId = params.account.agentId ?? route.agentId;
+	const agentId = normalizeAgentId(params.account.agentId ?? route.agentId);
 	if (agentId === route.agentId) return route;
+	const peer = {
+		kind: params.isDirect ? "direct" : "channel",
+		id: params.target
+	};
+	const dmScope = params.cfg.session?.dmScope ?? "main";
+	const sessionKey = runtime.channel.routing.buildAgentSessionKey({
+		agentId,
+		mainKey: params.cfg.session?.mainKey,
+		channel: CHANNEL_ID$1,
+		accountId: params.account.accountId,
+		peer,
+		dmScope,
+		identityLinks: params.cfg.session?.identityLinks
+	});
+	const mainSessionKey = runtime.channel.routing.buildAgentSessionKey({
+		agentId,
+		mainKey: params.cfg.session?.mainKey,
+		channel: CHANNEL_ID$1,
+		accountId: params.account.accountId,
+		dmScope: "main"
+	});
 	return {
 		...route,
 		agentId,
-		sessionKey: runtime.channel.routing.buildAgentSessionKey({
-			agentId,
-			channel: CHANNEL_ID$1,
-			accountId: params.account.accountId,
-			peer: {
-				kind: params.isDirect ? "direct" : "channel",
-				id: params.target
-			}
-		})
+		dmScope,
+		sessionKey,
+		mainSessionKey,
+		lastRoutePolicy: sessionKey === mainSessionKey ? "main" : "session"
 	};
 }
 async function dispatchModelReply(params) {
@@ -498,6 +762,22 @@ async function handleClickClackInbound(params) {
 		});
 		return;
 	}
+	let turnProvenance;
+	let activity;
+	if (params.account.agentActivity && (message.channel_id || message.direct_conversation_id)) activity = createClickClackActivityPublisher({
+		client: createClickClackClient({
+			baseUrl: params.account.baseUrl,
+			token: params.account.token
+		}),
+		target: message.channel_id ? { channelId: message.channel_id } : { conversationId: message.direct_conversation_id },
+		turnId: message.id,
+		onError: (error) => {
+			runtime.logging.getChildLogger({
+				plugin: "clickclack",
+				feature: "agent-activity"
+			}).warn(`clickclack activity publish failed: ${String(error)}`);
+		}
+	});
 	const senderName = message.author?.display_name || message.author_id;
 	const previousTimestamp = runtime.channel.session.readSessionUpdatedAt({
 		storePath: runtime.channel.session.resolveStorePath(params.config.session?.store, { agentId: route.agentId }),
@@ -540,7 +820,7 @@ async function handleClickClackInbound(params) {
 		OriginatingTo: target,
 		CommandAuthorized: access.commandAuthorized
 	});
-	await runtime.channel.inbound.dispatchReply({
+	const dispatchPromise = runtime.channel.inbound.dispatchReply({
 		cfg: params.config,
 		channel: CHANNEL_ID$1,
 		accountId: params.account.accountId,
@@ -551,6 +831,19 @@ async function handleClickClackInbound(params) {
 		recordInboundSession: runtime.channel.session.recordInboundSession,
 		dispatchReplyWithBufferedBlockDispatcher: runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
 		toolsAllow: params.account.toolsAllow,
+		replyOptions: activity ? {
+			onModelSelected: (ctx) => {
+				turnProvenance = {
+					model: ctx.provider && ctx.model ? `${ctx.provider}/${ctx.model}` : ctx.model,
+					thinking: ctx.thinkLevel
+				};
+				activity?.setProvenance(turnProvenance);
+			},
+			onItemEvent: activity.onItemEvent,
+			commentaryProgressEnabled: true,
+			suppressDefaultToolProgressMessages: true,
+			allowProgressCallbacksWhenSourceDeliverySuppressed: true
+		} : void 0,
 		delivery: {
 			deliver: async (payload) => {
 				const text = payload && typeof payload === "object" && "text" in payload ? payload.text ?? "" : "";
@@ -561,7 +854,8 @@ async function handleClickClackInbound(params) {
 					to: target,
 					text,
 					threadId: message.parent_message_id ? message.thread_root_id : void 0,
-					replyToId: message.id
+					replyToId: message.id,
+					provenance: turnProvenance
 				});
 			},
 			onError: (error) => {
@@ -573,6 +867,11 @@ async function handleClickClackInbound(params) {
 			throw error instanceof Error ? error : /* @__PURE__ */ new Error(`clickclack session record failed: ${String(error)}`);
 		} }
 	});
+	try {
+		await dispatchPromise;
+	} finally {
+		await activity?.finalize();
+	}
 }
 //#endregion
 //#region extensions/clickclack/src/gateway.ts
@@ -702,7 +1001,7 @@ async function startClickClackGatewayAccount(ctx) {
 							event,
 							botUserId: account.botUserId ?? ""
 						});
-					})().catch(reject);
+					})().catch((e) => reject(e instanceof Error ? e : new Error(`ClickClack ws message failed: ${formatErrorMessage(e)}`, { cause: e })));
 				});
 				socket.on("close", finishSocketCycle);
 				socket.on("error", (error) => {
@@ -814,6 +1113,7 @@ const clickClackPlugin = createChatChannelPlugin({
 						agentId,
 						channel: CHANNEL_ID,
 						accountId,
+						recipientSessionExact: parsed.kind === "dm",
 						peer: {
 							kind: parsed.chatType === "direct" ? "direct" : "channel",
 							id: buildClickClackTarget(parsed)
@@ -825,6 +1125,7 @@ const clickClackPlugin = createChatChannelPlugin({
 					replyToId,
 					threadId: threadId ?? (parsed.kind === "thread" ? parsed.id : void 0),
 					currentSessionKey,
+					useSuffix: false,
 					canRecoverCurrentThread: () => true
 				});
 			},

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as clickClackPlugin } from "./channel-OEzEDUUh.js";
+import { t as clickClackPlugin } from "./channel-1ZnJZTPl.js";
 export { clickClackPlugin };

package/dist/runtime-api.js

@@ -1,3 +1,3 @@
-import { d as resolveClickClackAccount, i as createClickClackClient, o as setClickClackRuntime, r as parseClickClackTarget } from "./channel-OEzEDUUh.js";
+import { d as resolveClickClackAccount, i as createClickClackClient, o as setClickClackRuntime, r as parseClickClackTarget } from "./channel-1ZnJZTPl.js";
 import "./api.js";
 export { createClickClackClient, parseClickClackTarget, resolveClickClackAccount, setClickClackRuntime };

package/npm-shrinkwrap.json

@@ -1,18 +1,18 @@
 {
   "name": "@openclaw/clickclack",
-  "version": "2026.7.1-beta.1",
+  "version": "2026.7.1-beta.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/clickclack",
-      "version": "2026.7.1-beta.1",
+      "version": "2026.7.1-beta.4",
       "dependencies": {
         "ws": "8.21.0",
         "zod": "4.4.3"
       },
       "peerDependencies": {
-        "openclaw": ">=2026.7.1-beta.1"
+        "openclaw": ">=2026.7.1-beta.4"
       },
       "peerDependenciesMeta": {
         "openclaw": {

package/openclaw.plugin.json

@@ -157,6 +157,9 @@
             "minimum": 100,
             "maximum": 60000
           },
+          "agentActivity": {
+            "type": "boolean"
+          },
           "accounts": {
             "type": "object",
             "propertyNames": {
@@ -299,6 +302,9 @@
                   "type": "integer",
                   "minimum": 100,
                   "maximum": 60000
+                },
+                "agentActivity": {
+                  "type": "boolean"
                 }
               },
               "additionalProperties": false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/clickclack",
-  "version": "2026.7.1-beta.1",
+  "version": "2026.7.1-beta.4",
   "description": "OpenClaw ClickClack channel plugin",
   "type": "module",
   "exports": {
@@ -13,7 +13,7 @@
     "zod": "4.4.3"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.7.1-beta.1"
+    "openclaw": ">=2026.7.1-beta.4"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -49,10 +49,10 @@
       "allowInvalidConfigRecovery": true
     },
     "compat": {
-      "pluginApi": ">=2026.7.1-beta.1"
+      "pluginApi": ">=2026.7.1-beta.4"
     },
     "build": {
-      "openclawVersion": "2026.7.1-beta.1",
+      "openclawVersion": "2026.7.1-beta.4",
       "bundledDist": false
     },
     "release": {