@openclaw/clickclack 2026.7.1-beta.6 → 2026.7.2-beta.1

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-1ZnJZTPl.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-Ds6d_3nx.js";
 export { DEFAULT_ACCOUNT_ID, buildClickClackTarget, clickClackConfigSchema, clickClackPlugin, createClickClackClient, getClickClackRuntime, listClickClackAccountIds, listEnabledClickClackAccounts, parseClickClackTarget, resolveClickClackAccount, resolveDefaultClickClackAccountId, setClickClackRuntime };

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

@@ -6,7 +6,7 @@ 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 { buildChannelProgressDraftLine, createMessageReceiptFromOutboundResults, defineChannelMessageAdapter } from "openclaw/plugin-sdk/channel-outbound";
+import { buildChannelProgressDraftLine, createMessageReceiptFromOutboundResults, defineChannelMessageAdapter, deriveDurableFinalDeliveryRequirements } 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";
@@ -17,6 +17,9 @@ 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";
+import { createHash } from "node:crypto";
+import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/outbound-media";
+import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
 //#region extensions/clickclack/src/accounts.ts
 /**
 * Resolves ClickClack account configuration from root channel config, named
@@ -230,12 +233,31 @@ function provenanceFields(provenance) {
 	return fields;
 }
 const CLICKCLACK_ERROR_BODY_LIMIT_BYTES = 8 * 1024;
+const CLICKCLACK_CORRELATION_ID_MAX_LENGTH = 128;
+const CLICKCLACK_CORRELATION_ID_PATTERN = /^[A-Za-z0-9._:-]+$/u;
+const CLICKCLACK_CORRELATION_ID_HEADER = "X-Correlation-ID";
+const CLICKCLACK_INBOUND_JSON_LIMIT_BYTES = 16 * 1024 * 1024;
+var ClickClackHttpError = class extends Error {
+	constructor(status, detail, headers) {
+		super(`ClickClack ${status}: ${detail}`);
+		this.status = status;
+		this.headers = headers;
+	}
+};
+/** Accepts the same bounded request-correlation shape as the ClickClack API. */
+function normalizeClickClackCorrelationId(value) {
+	if (typeof value !== "string") return;
+	const normalized = value.trim();
+	if (!normalized || normalized.length > CLICKCLACK_CORRELATION_ID_MAX_LENGTH || !CLICKCLACK_CORRELATION_ID_PATTERN.test(normalized)) return;
+	return normalized;
+}
 /**
 * Creates a typed client for the ClickClack API using bearer-token auth.
 */
 function createClickClackClient(options) {
 	const baseUrl = options.baseUrl.replace(/\/$/, "");
 	const fetcher = options.fetch ?? fetch;
+	const correlationId = normalizeClickClackCorrelationId(options.correlationId);
 	const headers = {
 		Authorization: `Bearer ${options.token}`,
 		Accept: "application/json"
@@ -243,6 +265,7 @@ function createClickClackClient(options) {
 	async function request(path, init = {}) {
 		const requestHeaders = new Headers(init.headers);
 		for (const [key, value] of Object.entries(headers)) requestHeaders.set(key, value);
+		if (correlationId) requestHeaders.set(CLICKCLACK_CORRELATION_ID_HEADER, correlationId);
 		if (init.body && !(init.body instanceof FormData)) requestHeaders.set("Content-Type", "application/json");
 		const response = await fetcher(`${baseUrl}${path}`, {
 			...init,
@@ -250,9 +273,20 @@ function createClickClackClient(options) {
 		});
 		if (!response.ok) {
 			const detail = await readResponseTextLimited(response, CLICKCLACK_ERROR_BODY_LIMIT_BYTES);
-			throw new Error(`ClickClack ${response.status}: ${detail}`);
+			throw new ClickClackHttpError(response.status, detail, new Headers(response.headers));
 		}
-		return await readProviderJsonResponse(response, "ClickClack response");
+		return await readProviderJsonResponse(response, "ClickClack response", { maxBytes: CLICKCLACK_INBOUND_JSON_LIMIT_BYTES });
+	}
+	async function fetchEventPage(workspaceId, pageOptions = {}) {
+		const query = new URLSearchParams({ workspace_id: workspaceId });
+		if (pageOptions.afterCursor) query.set("after_cursor", pageOptions.afterCursor);
+		if (pageOptions.limit !== void 0) query.set("limit", String(pageOptions.limit));
+		if (pageOptions.includeTail) query.set("include_tail", "true");
+		const data = await request(`/api/realtime/events?${query.toString()}`);
+		return {
+			events: data.events,
+			...typeof data.tail_cursor === "string" ? { tailCursor: data.tail_cursor } : {}
+		};
 	}
 	return {
 		me: async () => {
@@ -271,12 +305,31 @@ 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`),
+		message: async (messageId) => {
+			return (await request(`/api/messages/${encodeURIComponent(messageId)}`)).message;
+		},
+		findMessageByNonce: async (params) => {
+			const query = new URLSearchParams({
+				workspace_id: params.workspaceId,
+				nonce: params.nonce
+			});
+			try {
+				return (await request(`/api/messages/by-nonce?${query.toString()}`)).message;
+			} catch (error) {
+				if (error instanceof ClickClackHttpError && error.status === 404) {
+					if (error.headers.get("X-ClickClack-Message-Nonce") === "supported") return;
+					throw new Error("ClickClack server does not support durable message nonce lookup", { cause: error });
+				}
+				throw error;
+			}
+		},
 		createChannelMessage: async (channelId, body, opts) => {
 			return (await request(`/api/channels/${encodeURIComponent(channelId)}/messages`, {
 				method: "POST",
 				body: JSON.stringify({
 					body,
 					...opts?.quotedMessageId ? { quoted_message_id: opts.quotedMessageId } : {},
+					...opts?.nonce ? { nonce: opts.nonce } : {},
 					...provenanceFields(opts?.provenance)
 				})
 			})).message;
@@ -286,6 +339,7 @@ function createClickClackClient(options) {
 				method: "POST",
 				body: JSON.stringify({
 					body,
+					...opts?.nonce ? { nonce: opts.nonce } : {},
 					...provenanceFields(opts?.provenance)
 				})
 			})).message;
@@ -299,6 +353,38 @@ function createClickClackClient(options) {
 				})
 			})).conversation;
 		},
+		createUpload: async (params) => {
+			const form = new FormData();
+			const bytes = new Uint8Array(params.buffer);
+			form.append("file", new Blob([bytes], { type: params.contentType }), params.filename);
+			const query = new URLSearchParams({ workspace_id: params.workspaceId });
+			if (params.nonce) query.set("nonce", params.nonce);
+			return (await request(`/api/uploads?${query.toString()}`, {
+				method: "POST",
+				body: form
+			})).upload;
+		},
+		findUploadByNonce: async (params) => {
+			const query = new URLSearchParams({
+				workspace_id: params.workspaceId,
+				nonce: params.nonce
+			});
+			try {
+				return (await request(`/api/uploads/by-nonce?${query.toString()}`)).upload;
+			} catch (error) {
+				if (error instanceof ClickClackHttpError && error.status === 404) {
+					if (error.headers.get("X-ClickClack-Upload-Nonce") === "supported") return;
+					throw new Error("ClickClack server does not support durable upload nonce lookup", { cause: error });
+				}
+				throw error;
+			}
+		},
+		attachUpload: async (messageId, uploadId) => {
+			await request(`/api/messages/${encodeURIComponent(messageId)}/attachments`, {
+				method: "POST",
+				body: JSON.stringify({ upload_id: uploadId })
+			});
+		},
 		/**
 		* POSTs a durable agent activity row (agent_commentary / agent_tool)
 		* through the normal message create path. Requires a bot token carrying
@@ -328,21 +414,22 @@ function createClickClackClient(options) {
 				method: "POST",
 				body: JSON.stringify({
 					body,
-					...opts?.quotedMessageId ? { quoted_message_id: opts.quotedMessageId } : {}
+					...opts?.quotedMessageId ? { quoted_message_id: opts.quotedMessageId } : {},
+					...opts?.nonce ? { nonce: opts.nonce } : {}
 				})
 			})).message;
 		},
-		events: async (workspaceId, afterCursor) => {
-			const query = new URLSearchParams({ workspace_id: workspaceId });
-			if (afterCursor) query.set("after_cursor", afterCursor);
-			return (await request(`/api/realtime/events?${query.toString()}`)).events;
-		},
+		events: async (workspaceId, afterCursor) => (await fetchEventPage(workspaceId, { afterCursor })).events,
+		eventPage: fetchEventPage,
 		websocket: (workspaceId, afterCursor) => {
 			const url = new URL(`${baseUrl}/api/realtime/ws`);
 			url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
 			url.searchParams.set("workspace_id", workspaceId);
 			if (afterCursor) url.searchParams.set("after_cursor", afterCursor);
-			return new WebSocket(url, { headers: { Authorization: `Bearer ${options.token}` } });
+			return new WebSocket(url, {
+				headers: { Authorization: `Bearer ${options.token}` },
+				maxPayload: CLICKCLACK_INBOUND_JSON_LIMIT_BYTES
+			});
 		}
 	};
 }
@@ -612,52 +699,285 @@ function looksLikeClickClackTarget(raw) {
 * Outbound ClickClack delivery helpers for channel messages, thread replies,
 * and direct messages.
 */
-/**
-* Sends text to a normalized ClickClack target and returns the created message
-* id for receipt/session tracking.
-*/
-async function sendClickClackText(params) {
+const CLICKCLACK_MAX_UPLOAD_BYTES = 64 * 1024 * 1024;
+async function createTargetMessage(params) {
+	const parsed = parseClickClackTarget(params.to);
+	const explicitThreadId = params.threadId == null ? "" : String(params.threadId);
+	const replyToId = params.replyToId == null ? "" : String(params.replyToId);
+	if (explicitThreadId || parsed.kind === "thread") {
+		const rootId = explicitThreadId || parsed.id;
+		await params.onPlatformSendDispatch?.();
+		return await params.client.createThreadReply(rootId, params.text, {
+			provenance: params.provenance,
+			nonce: params.nonce
+		});
+	}
+	if (parsed.kind === "dm") {
+		await params.onPlatformSendDispatch?.();
+		const dm = await params.client.createDirectConversation(params.workspaceId, [parsed.id]);
+		return await params.client.createDirectMessage(dm.id, params.text, {
+			quotedMessageId: replyToId || void 0,
+			nonce: params.nonce
+		});
+	}
+	const channelId = await resolveChannelId(params.client, params.workspaceId, parsed.id);
+	await params.onPlatformSendDispatch?.();
+	return await params.client.createChannelMessage(channelId, params.text, {
+		provenance: params.provenance,
+		quotedMessageId: replyToId || void 0,
+		nonce: params.nonce
+	});
+}
+function durableDeliveryDigest(params) {
+	if (!params.deliveryQueueId) return;
+	if (!Number.isSafeInteger(params.deliveryPartIndex) || (params.deliveryPartIndex ?? -1) < 0) throw new Error("ClickClack durable delivery requires a stable delivery part index");
+	return createHash("sha256").update(`${params.deliveryQueueId}\n${params.deliveryPartIndex}`).digest("hex");
+}
+function mediaDeliveryNonces(params) {
+	const digest = durableDeliveryDigest(params);
+	if (!digest) return {};
+	return {
+		message: `openclaw-media:${digest}`,
+		upload: `openclaw-upload:${digest}`
+	};
+}
+function textDeliveryNonce(params) {
+	const digest = durableDeliveryDigest(params);
+	return digest ? `openclaw-text:${digest}` : void 0;
+}
+function createDispatchOnce(onPlatformSendDispatch) {
+	let dispatched = false;
+	return async () => {
+		if (dispatched) return;
+		await onPlatformSendDispatch?.();
+		dispatched = true;
+	};
+}
+async function attachUploadRetrySafe(params) {
+	try {
+		await params.client.attachUpload(params.messageId, params.uploadId);
+	} catch (firstError) {
+		try {
+			if ((await params.client.message(params.messageId)).attachments?.some((attachment) => attachment.id === params.uploadId)) return;
+		} catch {}
+		try {
+			await params.client.attachUpload(params.messageId, params.uploadId);
+		} catch {
+			throw firstError;
+		}
+	}
+}
+function createOutboundContext(params) {
 	const account = resolveClickClackAccount({
 		cfg: params.cfg,
 		accountId: params.accountId
 	});
-	const client = createClickClackClient({
-		baseUrl: account.baseUrl,
-		token: account.token
+	return {
+		account,
+		client: createClickClackClient({
+			baseUrl: account.baseUrl,
+			token: account.token,
+			correlationId: params.correlationId
+		})
+	};
+}
+/**
+* Sends visible text to a normalized ClickClack target and returns the created
+* message id, or undefined when sanitization removes all content.
+*/
+async function sendClickClackText(params) {
+	const text = sanitizeAssistantVisibleText(params.text);
+	if (!text) return;
+	const { account, client } = createOutboundContext(params);
+	const workspaceId = await resolveWorkspaceId(client, account.workspace);
+	const dispatch = createDispatchOnce(params.onPlatformSendDispatch);
+	return (await createTargetMessage({
+		client,
+		workspaceId,
+		to: params.to,
+		text,
+		threadId: params.threadId,
+		replyToId: params.replyToId,
+		provenance: params.provenance,
+		nonce: textDeliveryNonce({
+			deliveryQueueId: params.deliveryQueueId,
+			deliveryPartIndex: params.deliveryPartIndex
+		}),
+		onPlatformSendDispatch: dispatch
+	})).id;
+}
+/** Resolves, uploads, sends, then attaches one file to a ClickClack message. */
+async function sendClickClackMedia(params) {
+	const nonces = mediaDeliveryNonces({
+		deliveryQueueId: params.deliveryQueueId,
+		deliveryPartIndex: params.deliveryPartIndex
+	});
+	const preloadedMedia = nonces.upload ? void 0 : await loadOutboundMediaFromUrl(params.mediaUrl, {
+		maxBytes: CLICKCLACK_MAX_UPLOAD_BYTES,
+		mediaAccess: params.mediaAccess,
+		mediaLocalRoots: params.mediaLocalRoots,
+		mediaReadFile: params.mediaReadFile
 	});
+	const { account, client } = createOutboundContext(params);
 	const workspaceId = await resolveWorkspaceId(client, account.workspace);
-	const parsed = parseClickClackTarget(params.to);
-	const explicitThreadId = params.threadId == null ? "" : String(params.threadId);
-	const replyToId = params.replyToId == null ? "" : String(params.replyToId);
-	if (explicitThreadId || parsed.kind === "thread") {
-		const rootId = explicitThreadId || parsed.id;
-		const message = await client.createThreadReply(rootId, params.text, { provenance: params.provenance });
+	const persistedUpload = nonces.upload ? await client.findUploadByNonce({
+		workspaceId,
+		nonce: nonces.upload
+	}) : void 0;
+	const dispatch = createDispatchOnce(params.onPlatformSendDispatch);
+	let upload = persistedUpload;
+	let mediaFilename = preloadedMedia?.fileName?.trim();
+	if (!upload) {
+		const media = preloadedMedia ?? await loadOutboundMediaFromUrl(params.mediaUrl, {
+			maxBytes: CLICKCLACK_MAX_UPLOAD_BYTES,
+			mediaAccess: params.mediaAccess,
+			mediaLocalRoots: params.mediaLocalRoots,
+			mediaReadFile: params.mediaReadFile
+		});
+		const filename = media.fileName?.trim() || "attachment";
+		mediaFilename = filename;
+		const contentType = media.contentType?.trim() || "application/octet-stream";
+		await dispatch();
+		upload = await client.createUpload({
+			workspaceId,
+			buffer: media.buffer,
+			filename,
+			contentType,
+			...nonces.upload ? { nonce: nonces.upload } : {}
+		});
+	}
+	const text = sanitizeAssistantVisibleText(params.text) || mediaFilename || upload.filename || "attachment";
+	const message = await createTargetMessage({
+		client,
+		workspaceId,
+		to: params.to,
+		text,
+		threadId: params.threadId,
+		replyToId: params.replyToId,
+		nonce: nonces.message,
+		onPlatformSendDispatch: dispatch
+	});
+	await attachUploadRetrySafe({
+		client,
+		messageId: message.id,
+		uploadId: upload.id
+	});
+	return message.id;
+}
+function collectReconciliationMediaUrls(ctx) {
+	const planned = ctx.renderedBatchPlan?.items[0]?.mediaUrls;
+	if (planned?.length) return planned.map((url) => url.trim()).filter(Boolean);
+	const payload = ctx.payloads[0];
+	return [payload?.mediaUrl, ...payload?.mediaUrls ?? []].map((url) => url?.trim()).filter((url) => Boolean(url));
+}
+/**
+* Completes an unknown durable send through ClickClack's message/upload nonces.
+* Media recovery never rereads the original source after restart.
+*/
+async function reconcileClickClackUnknownSend(ctx) {
+	if (ctx.payloads.length !== 1 || (ctx.renderedBatchPlan?.items.length ?? 1) !== 1) return {
+		status: "unresolved",
+		error: "ClickClack reconciliation requires exactly one payload"
+	};
+	const mediaUrls = collectReconciliationMediaUrls(ctx);
+	const { account, client } = createOutboundContext({
+		cfg: ctx.cfg,
+		accountId: ctx.accountId
+	});
+	const workspaceId = await resolveWorkspaceId(client, account.workspace);
+	const effectiveReplyToId = ctx.effectiveReplyToId !== void 0 ? ctx.effectiveReplyToId : ctx.replyToMode === "off" ? void 0 : ctx.replyToId;
+	const payload = ctx.payloads[0];
+	const caption = ctx.renderedBatchPlan?.items[0]?.text ?? payload?.text ?? "";
+	if (mediaUrls.length === 0) {
+		const nonce = textDeliveryNonce({
+			deliveryQueueId: ctx.queueId,
+			deliveryPartIndex: 0
+		});
+		if (!nonce || !sanitizeAssistantVisibleText(caption)) return { status: "not_sent" };
+		const message = await client.findMessageByNonce({
+			workspaceId,
+			nonce
+		});
+		if (!message) return { status: "not_sent" };
+		const receipt = createMessageReceiptFromOutboundResults({
+			results: [{
+				channel: "clickclack",
+				messageId: message.id
+			}],
+			threadId: ctx.threadId == null ? void 0 : String(ctx.threadId),
+			replyToId: effectiveReplyToId ?? void 0,
+			kind: "text"
+		});
 		return {
-			to: params.to,
-			messageId: message.id
+			status: "sent",
+			messageId: message.id,
+			receipt
 		};
 	}
-	if (parsed.kind === "dm") {
-		const dm = await client.createDirectConversation(workspaceId, [parsed.id]);
-		const message = await client.createDirectMessage(dm.id, params.text, { quotedMessageId: replyToId || void 0 });
+	const parts = await Promise.all(mediaUrls.map(async (_mediaUrl, index) => {
+		const nonces = mediaDeliveryNonces({
+			deliveryQueueId: ctx.queueId,
+			deliveryPartIndex: index
+		});
+		if (!nonces.upload || !nonces.message) throw new Error("ClickClack durable media nonces were not derived");
+		const [upload, message] = await Promise.all([client.findUploadByNonce({
+			workspaceId,
+			nonce: nonces.upload
+		}), client.findMessageByNonce({
+			workspaceId,
+			nonce: nonces.message
+		})]);
 		return {
-			to: params.to,
-			messageId: message.id
+			upload,
+			message
+		};
+	}));
+	for (const part of parts) {
+		if (part.message && !part.upload) return {
+			status: "unresolved",
+			error: `ClickClack message ${part.message.id} exists without its nonce-keyed upload`,
+			retryable: false
 		};
+		if (!part.message) return { status: "not_sent" };
 	}
-	const channelId = await resolveChannelId(client, workspaceId, parsed.id);
-	const message = await client.createChannelMessage(channelId, params.text, {
-		provenance: params.provenance,
-		quotedMessageId: replyToId || void 0
+	const messageIds = [];
+	for (const part of parts) {
+		const message = part.message;
+		const upload = part.upload;
+		if (!message || !upload) throw new Error("ClickClack reconciliation state changed unexpectedly");
+		if (!message.attachments?.some((attachment) => attachment.id === upload.id)) await attachUploadRetrySafe({
+			client,
+			messageId: message.id,
+			uploadId: upload.id
+		});
+		messageIds.push(message.id);
+	}
+	const receipt = createMessageReceiptFromOutboundResults({
+		results: messageIds.map((messageId) => ({
+			channel: "clickclack",
+			messageId
+		})),
+		threadId: ctx.threadId == null ? void 0 : String(ctx.threadId),
+		replyToId: effectiveReplyToId ?? void 0,
+		kind: "media"
 	});
+	const messageId = messageIds.at(-1);
 	return {
-		to: params.to,
-		messageId: message.id
+		status: "sent",
+		...messageId ? { messageId } : {},
+		receipt
 	};
 }
 //#endregion
 //#region extensions/clickclack/src/inbound.ts
 const CHANNEL_ID$1 = "clickclack";
+const CLICKCLACK_MESSAGE_ID_PATTERN = /^msg_[0-9a-hjkmnp-tv-z]{26}$/u;
+function hasClickClackReplyMedia(payload) {
+	return Boolean(payload.mediaUrl?.trim() || payload.mediaUrls?.some((mediaUrl) => typeof mediaUrl === "string" && mediaUrl.trim()));
+}
+function resolveClickClackAgentRunId(messageId) {
+	return CLICKCLACK_MESSAGE_ID_PATTERN.test(messageId) ? `${CHANNEL_ID$1}:${messageId}` : void 0;
+}
 function resolveAccountAgentRoute(params) {
 	const runtime = getClickClackRuntime();
 	const route = runtime.channel.routing.resolveAgentRoute({
@@ -702,10 +1022,10 @@ function resolveAccountAgentRoute(params) {
 	};
 }
 async function dispatchModelReply(params) {
-	const text = (await getClickClackRuntime().llm.complete({
+	const runtime = getClickClackRuntime();
+	const text = (await runtime.llm.complete({
 		agentId: params.route.agentId,
 		model: params.account.model,
-		maxTokens: 96,
 		purpose: "clickclack bot reply",
 		systemPrompt: params.account.systemPrompt,
 		messages: [{
@@ -713,14 +1033,21 @@ async function dispatchModelReply(params) {
 			content: params.message.body
 		}]
 	})).text.trim();
-	if (!text) return;
+	if (!text) {
+		runtime.logging.getChildLogger({
+			plugin: "clickclack",
+			feature: "model-reply"
+		}).warn(`[${params.account.accountId}] ClickClack model reply produced no sendable text`);
+		return;
+	}
 	await sendClickClackText({
 		cfg: params.cfg,
 		accountId: params.account.accountId,
 		to: params.target,
 		text,
 		threadId: params.message.parent_message_id ? params.message.thread_root_id : void 0,
-		replyToId: params.message.id
+		replyToId: params.message.id,
+		correlationId: params.correlationId
 	});
 }
 /**
@@ -758,7 +1085,8 @@ async function handleClickClackInbound(params) {
 			cfg: params.config,
 			message,
 			route,
-			target
+			target,
+			correlationId: params.correlationId
 		});
 		return;
 	}
@@ -767,7 +1095,8 @@ async function handleClickClackInbound(params) {
 	if (params.account.agentActivity && (message.channel_id || message.direct_conversation_id)) activity = createClickClackActivityPublisher({
 		client: createClickClackClient({
 			baseUrl: params.account.baseUrl,
-			token: params.account.token
+			token: params.account.token,
+			correlationId: params.correlationId
 		}),
 		target: message.channel_id ? { channelId: message.channel_id } : { conversationId: message.direct_conversation_id },
 		turnId: message.id,
@@ -820,6 +1149,20 @@ async function handleClickClackInbound(params) {
 		OriginatingTo: target,
 		CommandAuthorized: access.commandAuthorized
 	});
+	const runId = resolveClickClackAgentRunId(message.id);
+	const activityReplyOptions = 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;
 	const dispatchPromise = runtime.channel.inbound.dispatchReply({
 		cfg: params.config,
 		channel: CHANNEL_ID$1,
@@ -831,21 +1174,13 @@ 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
+		replyOptions: runId || activityReplyOptions ? {
+			...runId ? { runId } : {},
+			...activityReplyOptions
 		} : void 0,
 		delivery: {
 			deliver: async (payload) => {
+				if (hasClickClackReplyMedia(payload)) throw new Error("ClickClack media reply requires durable delivery");
 				const text = payload && typeof payload === "object" && "text" in payload ? payload.text ?? "" : "";
 				if (!text.trim()) return;
 				await sendClickClackText({
@@ -855,9 +1190,25 @@ async function handleClickClackInbound(params) {
 					text,
 					threadId: message.parent_message_id ? message.thread_root_id : void 0,
 					replyToId: message.id,
-					provenance: turnProvenance
+					provenance: turnProvenance,
+					correlationId: params.correlationId
 				});
 			},
+			durable: (payload) => {
+				if (!hasClickClackReplyMedia(payload)) return false;
+				const threadId = message.parent_message_id ? message.thread_root_id : void 0;
+				return {
+					to: target,
+					threadId,
+					replyToId: message.id,
+					requiredCapabilities: deriveDurableFinalDeliveryRequirements({
+						payload,
+						threadId,
+						replyToId: message.id,
+						reconcileUnknownSend: true
+					})
+				};
+			},
 			onError: (error) => {
 				throw error instanceof Error ? error : /* @__PURE__ */ new Error(`clickclack dispatch failed: ${String(error)}`);
 			}
@@ -875,10 +1226,14 @@ async function handleClickClackInbound(params) {
 }
 //#endregion
 //#region extensions/clickclack/src/gateway.ts
+const CLICKCLACK_EVENT_PAGE_LIMIT = 500;
 function payloadString(event, key) {
 	const value = event.payload?.[key];
 	return typeof value === "string" ? value : "";
 }
+function eventCorrelationId(event) {
+	return normalizeClickClackCorrelationId(event.payload?.correlation_id);
+}
 async function resolveEventMessage(params) {
 	const messageId = payloadString(params.event, "message_id");
 	if (!messageId) return null;
@@ -908,8 +1263,13 @@ function parseSocketEvent(data) {
 async function processEvent(params) {
 	if (params.event.type !== "message.created" && params.event.type !== "thread.reply_created") return;
 	if (payloadString(params.event, "author_id") === params.botUserId) return;
+	const correlationId = eventCorrelationId(params.event);
 	const message = await resolveEventMessage({
-		client: params.client,
+		client: correlationId ? createClickClackClient({
+			baseUrl: params.account.baseUrl,
+			token: params.account.token,
+			correlationId
+		}) : params.client,
 		event: params.event
 	});
 	if (!message || message.author_id === params.botUserId) return;
@@ -924,9 +1284,27 @@ async function processEvent(params) {
 		account: params.account,
 		config: params.config,
 		message,
-		access
+		access,
+		...correlationId ? { correlationId } : {}
 	});
 }
+async function drainEventBacklog(params) {
+	let afterCursor = params.afterCursor;
+	while (!params.abortSignal.aborted) {
+		const events = (await params.client.eventPage(params.workspaceId, {
+			afterCursor,
+			limit: CLICKCLACK_EVENT_PAGE_LIMIT
+		})).events;
+		for (const event of events) {
+			if (params.abortSignal.aborted) return afterCursor;
+			if (!event.cursor || event.cursor === afterCursor) throw new Error("ClickClack event backlog returned a non-advancing cursor");
+			await params.onEvent(event);
+			afterCursor = event.cursor;
+		}
+		if (events.length === 0) return afterCursor;
+	}
+	return afterCursor;
+}
 async function startClickClackGatewayAccount(ctx) {
 	const configuredAccount = resolveClickClackAccount({
 		cfg: ctx.cfg,
@@ -955,20 +1333,27 @@ async function startClickClackGatewayAccount(ctx) {
 	let initialized = false;
 	try {
 		while (!ctx.abortSignal.aborted) {
-			const backlog = await client.events(workspaceId, afterCursor);
 			if (!initialized) {
-				for (const event of backlog) afterCursor = event.cursor || afterCursor;
+				const page = await client.eventPage(workspaceId, { includeTail: true });
+				if (page.tailCursor !== void 0) afterCursor = page.tailCursor;
+				else for (const event of page.events) afterCursor = event.cursor || afterCursor;
 				initialized = true;
-			} else for (const event of backlog) {
-				afterCursor = event.cursor || afterCursor;
-				await processEvent({
-					account,
-					config: ctx.cfg,
-					client,
-					event,
-					botUserId: account.botUserId
-				});
-			}
+			} else afterCursor = await drainEventBacklog({
+				client,
+				workspaceId,
+				afterCursor,
+				abortSignal: ctx.abortSignal,
+				onEvent: async (event) => {
+					await processEvent({
+						account,
+						config: ctx.cfg,
+						client,
+						event,
+						botUserId: account.botUserId
+					});
+				}
+			});
+			if (ctx.abortSignal.aborted) break;
 			const socket = client.websocket(workspaceId, afterCursor);
 			await new Promise((resolve, reject) => {
 				let settled = false;
@@ -1035,36 +1420,81 @@ const CHANNEL_ID = "clickclack";
 const meta = { ...getChatChannelMeta(CHANNEL_ID) };
 const clickClackMessageAdapter = defineChannelMessageAdapter({
 	id: CHANNEL_ID,
-	durableFinal: { capabilities: {
-		text: true,
-		replyTo: true,
-		thread: true,
-		messageSendingHooks: true
-	} },
-	send: { text: async (ctx) => {
-		const result = await sendClickClackText({
-			cfg: ctx.cfg,
-			accountId: ctx.accountId,
-			to: ctx.to,
-			text: ctx.text,
-			threadId: ctx.threadId,
-			replyToId: ctx.replyToId
-		});
-		const threadId = ctx.threadId == null ? void 0 : String(ctx.threadId);
-		const replyToId = ctx.replyToId ?? void 0;
-		return {
-			messageId: result.messageId,
-			receipt: createMessageReceiptFromOutboundResults({
-				results: [{
-					channel: CHANNEL_ID,
-					messageId: result.messageId
-				}],
-				threadId,
-				replyToId,
-				kind: "text"
-			})
-		};
-	} }
+	durableFinal: {
+		capabilities: {
+			text: true,
+			media: true,
+			replyTo: true,
+			thread: true,
+			messageSendingHooks: true,
+			reconcileUnknownSend: true
+		},
+		reconcileUnknownSendKinds: {
+			text: true,
+			media: true
+		},
+		reconcileUnknownSend: reconcileClickClackUnknownSend
+	},
+	send: {
+		text: async (ctx) => {
+			const messageId = await sendClickClackText({
+				cfg: ctx.cfg,
+				accountId: ctx.accountId,
+				to: ctx.to,
+				text: ctx.text,
+				threadId: ctx.threadId,
+				replyToId: ctx.replyToId,
+				deliveryQueueId: ctx.deliveryQueueId,
+				deliveryPartIndex: ctx.deliveryPartIndex,
+				onPlatformSendDispatch: ctx.onPlatformSendDispatch
+			});
+			const threadId = ctx.threadId == null ? void 0 : String(ctx.threadId);
+			const replyToId = ctx.replyToId ?? void 0;
+			return {
+				...messageId ? { messageId } : {},
+				receipt: createMessageReceiptFromOutboundResults({
+					results: messageId ? [{
+						channel: CHANNEL_ID,
+						messageId
+					}] : [],
+					threadId,
+					replyToId,
+					kind: "text"
+				})
+			};
+		},
+		media: async (ctx) => {
+			const messageId = await sendClickClackMedia({
+				cfg: ctx.cfg,
+				accountId: ctx.accountId,
+				to: ctx.to,
+				text: ctx.text,
+				mediaUrl: ctx.mediaUrl,
+				mediaAccess: ctx.mediaAccess,
+				mediaLocalRoots: ctx.mediaLocalRoots,
+				mediaReadFile: ctx.mediaReadFile,
+				threadId: ctx.threadId,
+				replyToId: ctx.replyToId,
+				deliveryQueueId: ctx.deliveryQueueId,
+				deliveryPartIndex: ctx.deliveryPartIndex,
+				onPlatformSendDispatch: ctx.onPlatformSendDispatch
+			});
+			const threadId = ctx.threadId == null ? void 0 : String(ctx.threadId);
+			const replyToId = ctx.replyToId ?? void 0;
+			return {
+				messageId,
+				receipt: createMessageReceiptFromOutboundResults({
+					results: [{
+						channel: CHANNEL_ID,
+						messageId
+					}],
+					threadId,
+					replyToId,
+					kind: "media"
+				})
+			};
+		}
+	}
 });
 /**
 * Channel plugin instance registered by the bundled ClickClack entry.
@@ -1162,14 +1592,37 @@ const clickClackPlugin = createChatChannelPlugin({
 		base: { deliveryMode: "direct" },
 		attachedResults: {
 			channel: CHANNEL_ID,
-			sendText: async ({ cfg, to, text, accountId, threadId, replyToId }) => await sendClickClackText({
-				cfg,
-				accountId,
-				to,
-				text,
-				threadId,
-				replyToId
-			})
+			sendText: async ({ cfg, to, text, accountId, threadId, replyToId, deliveryQueueId, deliveryPartIndex, onPlatformSendDispatch }) => {
+				return { messageId: await sendClickClackText({
+					cfg,
+					accountId,
+					to,
+					text,
+					threadId,
+					replyToId,
+					deliveryQueueId,
+					deliveryPartIndex,
+					onPlatformSendDispatch
+				}) ?? "" };
+			},
+			sendMedia: async ({ cfg, to, text, mediaUrl, mediaAccess, mediaLocalRoots, mediaReadFile, accountId, threadId, replyToId, deliveryQueueId, deliveryPartIndex, onPlatformSendDispatch }) => {
+				if (!mediaUrl) throw new Error("ClickClack media send requires mediaUrl");
+				return { messageId: await sendClickClackMedia({
+					cfg,
+					accountId,
+					to,
+					text,
+					mediaUrl,
+					mediaAccess,
+					mediaLocalRoots,
+					mediaReadFile,
+					threadId,
+					replyToId,
+					deliveryQueueId,
+					deliveryPartIndex,
+					onPlatformSendDispatch
+				}) };
+			}
 		}
 	}
 });

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as clickClackPlugin } from "./channel-1ZnJZTPl.js";
+import { t as clickClackPlugin } from "./channel-Ds6d_3nx.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-1ZnJZTPl.js";
+import { d as resolveClickClackAccount, i as createClickClackClient, o as setClickClackRuntime, r as parseClickClackTarget } from "./channel-Ds6d_3nx.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.6",
+  "version": "2026.7.2-beta.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/clickclack",
-      "version": "2026.7.1-beta.6",
+      "version": "2026.7.2-beta.1",
       "dependencies": {
         "ws": "8.21.0",
         "zod": "4.4.3"
       },
       "peerDependencies": {
-        "openclaw": ">=2026.7.1-beta.6"
+        "openclaw": ">=2026.7.2-beta.1"
       },
       "peerDependenciesMeta": {
         "openclaw": {

package/package.json

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