@openclaw/clickclack 2026.7.2-beta.2 → 2026.7.2-beta.4

package/dist/{channel-BnREQIP8.js → channel-BDq0KWDB.js}

@@ -1,4 +1,4 @@
-import { a as createClickClackClient, c as CLICKCLACK_CHANNEL_ID, d as DEFAULT_ACCOUNT_ID, i as resolveWorkspaceId, l as clickClackConfigAdapter, m as resolveClickClackAccount, n as clickClackSetupAdapter, o as normalizeClickClackCorrelationId, r as resolveChannelId, s as clickClackConfigSchema, t as clickClackSetupWizard, u as clickClackMeta } from "./setup-surface-B346XaAu.js";
+import { _ as clickClackMeta, b as listEnabledClickClackAccounts, c as resolveChannelId, d as createClickClackClient, g as clickClackConfigAdapter, h as CLICKCLACK_CHANNEL_ID, l as resolveWorkspaceId, m as clickClackConfigSchema, n as clickClackSetupAdapter, p as normalizeClickClackCorrelationId, r as clickClackSetupContract, t as clickClackSetupWizard, v as DEFAULT_ACCOUNT_ID, x as resolveClickClackAccount } from "./setup-surface-Baf26N-D.js";
 import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-BKkzzjBA.js";
 import { buildChannelOutboundSessionRoute, buildThreadAwareOutboundSessionRoute, createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
 import { buildChannelProgressDraftLine, createMessageReceiptFromOutboundResults, defineChannelMessageAdapter, deriveDurableFinalDeliveryRequirements } from "openclaw/plugin-sdk/channel-outbound";
@@ -8,10 +8,11 @@ import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { resolveStableChannelMessageIngress } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
 import { listNativeCommandSpecsForConfig } from "openclaw/plugin-sdk/native-command-registry";
+import { createChannelInboundEnvelopeBuilder } from "openclaw/plugin-sdk/channel-inbound";
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/outbound-media";
-import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
+import { renderMarkdownWithMarkers, sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
 //#region extensions/clickclack/src/runtime.ts
 /**
 * Runtime store for host-provided OpenClaw services used by the ClickClack
@@ -327,6 +328,336 @@ function createClickClackActivityPublisher(params) {
 	};
 }
 //#endregion
+//#region extensions/clickclack/src/discussions/binding-generation.ts
+const DISCUSSION_GENERATIONS_NAMESPACE = "discussion-binding-generations";
+const MAX_PENDING_DISCUSSION_GENERATIONS = 1e4;
+const storesByRuntime$2 = /* @__PURE__ */ new WeakMap();
+function getGenerationStore(runtime) {
+	const existing = storesByRuntime$2.get(runtime);
+	if (existing) return existing;
+	const created = runtime.state.openSyncKeyedStore({
+		namespace: DISCUSSION_GENERATIONS_NAMESPACE,
+		maxEntries: MAX_PENDING_DISCUSSION_GENERATIONS,
+		overflowPolicy: "reject-new"
+	});
+	storesByRuntime$2.set(runtime, created);
+	return created;
+}
+/** Reserves a generation so an interrupted channel create can be adopted on retry. */
+function reserveDiscussionBindingGeneration(params) {
+	const store = getGenerationStore(params.runtime);
+	const existing = store.lookup(params.sessionKey);
+	if (existing?.destinationIdentity === params.destinationIdentity) return existing.generation;
+	const generation = (params.createGeneration ?? randomUUID)();
+	store.register(params.sessionKey, {
+		destinationIdentity: params.destinationIdentity,
+		generation
+	});
+	return generation;
+}
+/** Clears only the completed reservation; future opens must mint a new ownership ref. */
+function clearDiscussionBindingGeneration(params) {
+	const store = getGenerationStore(params.runtime);
+	const existing = store.lookup(params.sessionKey);
+	if (!existing) return;
+	if (params.expectedGeneration && existing.generation !== params.expectedGeneration) return;
+	store.delete(params.sessionKey);
+}
+/** Quarantines a destination before the first fallible channel create. */
+function recordPendingDiscussionOpen(params) {
+	const store = getGenerationStore(params.runtime);
+	const existing = store.lookup(params.sessionKey);
+	if (!existing || existing.generation !== params.generation) throw new Error("ClickClack discussion generation changed before channel creation");
+	store.register(params.sessionKey, {
+		...existing,
+		pending: params.pending
+	});
+}
+function listPendingDiscussionOpens(runtime) {
+	return getGenerationStore(runtime).entries().flatMap((entry) => entry.value.pending ? [{
+		sessionKey: entry.key,
+		generation: entry.value.generation,
+		...entry.value.pending
+	}] : []);
+}
+function hasPendingDiscussionOpenForDestination(params) {
+	const serverBaseUrl = params.serverBaseUrl.replace(/\/+$/u, "");
+	return listPendingDiscussionOpens(params.runtime).some((pending) => pending.serverBaseUrl === serverBaseUrl && pending.workspaceId === params.workspaceId);
+}
+//#endregion
+//#region extensions/clickclack/src/discussions/naming.ts
+function shortSessionHash(sessionKey) {
+	return createHash("sha256").update(sessionKey).digest("hex").slice(0, 32);
+}
+function fallbackDiscussionLabel(sessionKey) {
+	return `s-${shortSessionHash(sessionKey)}`;
+}
+function resolveDiscussionLabel(label, sessionKey) {
+	return label?.trim() || fallbackDiscussionLabel(sessionKey);
+}
+function slugifyDiscussionLabel(label, sessionKey) {
+	return label.normalize("NFKD").replace(/[\u0300-\u036f]/gu, "").toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "").slice(0, 80).replace(/-+$/gu, "") || fallbackDiscussionLabel(sessionKey);
+}
+function discussionSessionPeerId(identity) {
+	return `disc-${createHash("sha256").update([
+		identity.mainSessionKey,
+		identity.sessionId,
+		identity.serverBaseUrl,
+		identity.channelId,
+		identity.externalRef
+	].join("\0")).digest("hex").slice(0, 32)}`;
+}
+function isDiscussionSessionKey(sessionKey) {
+	return sessionKey.includes(":clickclack:") && /:channel:disc-[0-9a-f]{32}$/u.test(sessionKey);
+}
+function discussionExternalRef(installationId, mainSessionKey, sessionId, destinationIdentity, bindingGeneration) {
+	return `openclaw:${installationId}:${shortSessionHash([
+		mainSessionKey,
+		sessionId,
+		destinationIdentity,
+		bindingGeneration
+	].join("\0"))}`;
+}
+function discussionCredentialFingerprint(token) {
+	return createHash("sha256").update(token).digest("hex");
+}
+function discussionSessionKey(params) {
+	return params.runtime.channel.routing.buildAgentSessionKey({
+		agentId: params.agentId,
+		channel: "clickclack",
+		accountId: params.accountId,
+		peer: {
+			kind: "channel",
+			id: discussionSessionPeerId(params)
+		}
+	});
+}
+//#endregion
+//#region extensions/clickclack/src/discussions/binding-store.ts
+function bindingMatchesSessionIncarnation(runtime, sessionKey, binding) {
+	const entry = runtime.agent.session.getSessionEntry({
+		sessionKey,
+		readConsistency: "latest"
+	});
+	return Boolean(entry && binding.sessionId && entry.sessionId === binding.sessionId);
+}
+function bindingMatchesActiveSessionIncarnation(runtime, sessionKey, binding) {
+	const entry = runtime.agent.session.getSessionEntry({
+		sessionKey,
+		readConsistency: "latest"
+	});
+	return Boolean(entry && binding.sessionId && entry.sessionId === binding.sessionId && entry.archivedAt === void 0);
+}
+const DISCUSSION_BINDINGS_NAMESPACE = "discussion-bindings";
+const MAX_DISCUSSION_BINDINGS = 1e4;
+const storesByRuntime$1 = /* @__PURE__ */ new WeakMap();
+function channelKey(serverBaseUrl, channelId) {
+	return `${serverBaseUrl.replace(/\/+$/u, "")}\0${channelId}`;
+}
+/** SQLite-backed session/channel bindings with a process-local inbound lookup index. */
+var ClickClackDiscussionBindingStore = class {
+	#store;
+	#sessionByChannel = /* @__PURE__ */ new Map();
+	#mainByDiscussionSession = /* @__PURE__ */ new Map();
+	#runtime;
+	constructor(runtime) {
+		this.#runtime = runtime;
+		this.#store = runtime.state.openSyncKeyedStore({
+			namespace: DISCUSSION_BINDINGS_NAMESPACE,
+			maxEntries: MAX_DISCUSSION_BINDINGS,
+			overflowPolicy: "reject-new"
+		});
+		for (const entry of this.#store.entries()) this.#index(entry.key, entry.value);
+	}
+	get(sessionKey) {
+		return this.#store.lookup(sessionKey);
+	}
+	hasCapacity(sessionKey) {
+		return this.get(sessionKey) !== void 0 || this.#store.entries().length < MAX_DISCUSSION_BINDINGS;
+	}
+	getByChannel(serverBaseUrl, channelId) {
+		const key = channelKey(serverBaseUrl, channelId);
+		const sessionKey = this.#sessionByChannel.get(key);
+		if (!sessionKey) return;
+		const binding = this.get(sessionKey);
+		if (!binding) {
+			this.#sessionByChannel.delete(key);
+			return;
+		}
+		return {
+			sessionKey,
+			binding
+		};
+	}
+	set(sessionKey, binding) {
+		const previous = this.get(sessionKey);
+		this.#store.register(sessionKey, binding);
+		if (previous) this.#unindex(sessionKey, previous);
+		this.#index(sessionKey, binding);
+	}
+	delete(sessionKey) {
+		const previous = this.get(sessionKey);
+		const deleted = this.#store.delete(sessionKey);
+		if (deleted && previous) this.#unindex(sessionKey, previous);
+		return deleted;
+	}
+	getByDiscussionSession(sideSessionKey) {
+		const sessionKey = this.#mainByDiscussionSession.get(sideSessionKey);
+		if (!sessionKey) return;
+		const binding = this.get(sessionKey);
+		return binding ? {
+			sessionKey,
+			binding
+		} : void 0;
+	}
+	entries() {
+		return this.#store.entries().map((entry) => ({
+			sessionKey: entry.key,
+			binding: entry.value
+		}));
+	}
+	#index(sessionKey, binding) {
+		this.#sessionByChannel.set(channelKey(binding.serverBaseUrl, binding.channelId), sessionKey);
+		const sideSessionKey = discussionSessionKey({
+			runtime: this.#runtime,
+			agentId: binding.agentId,
+			mainSessionKey: sessionKey,
+			sessionId: binding.sessionId,
+			accountId: binding.accountId,
+			serverBaseUrl: binding.serverBaseUrl,
+			channelId: binding.channelId,
+			externalRef: binding.externalRef
+		});
+		if (sideSessionKey) this.#mainByDiscussionSession.set(sideSessionKey, sessionKey);
+	}
+	#unindex(sessionKey, binding) {
+		this.#sessionByChannel.delete(channelKey(binding.serverBaseUrl, binding.channelId));
+		const sideSessionKey = discussionSessionKey({
+			runtime: this.#runtime,
+			agentId: binding.agentId,
+			mainSessionKey: sessionKey,
+			sessionId: binding.sessionId,
+			accountId: binding.accountId,
+			serverBaseUrl: binding.serverBaseUrl,
+			channelId: binding.channelId,
+			externalRef: binding.externalRef
+		});
+		if (sideSessionKey) this.#mainByDiscussionSession.delete(sideSessionKey);
+	}
+};
+function getClickClackDiscussionBindingStore(runtime) {
+	const existing = storesByRuntime$1.get(runtime);
+	if (existing) return existing;
+	const created = new ClickClackDiscussionBindingStore(runtime);
+	storesByRuntime$1.set(runtime, created);
+	return created;
+}
+//#endregion
+//#region extensions/clickclack/src/discussions/eligibility.ts
+function discussionAccounts(cfg) {
+	return listEnabledClickClackAccounts(cfg).filter((account) => account.configured && account.discussions.enabled);
+}
+function normalizedServerBaseUrl(account) {
+	return account.baseUrl.replace(/\/+$/u, "");
+}
+/** Resolves the sole live account and rejects bindings pinned to an older destination. */
+function resolveDiscussionBindingAccount(cfg, binding) {
+	const accounts = discussionAccounts(cfg);
+	if (accounts.length !== 1) return { state: "unavailable" };
+	const account = accounts[0];
+	if (!account) return { state: "unavailable" };
+	if (account.accountId !== binding.accountId || normalizedServerBaseUrl(account) !== binding.serverBaseUrl || account.discussions.workspace !== binding.workspaceRef || binding.credentialFingerprint !== void 0 && discussionCredentialFingerprint(account.token) !== binding.credentialFingerprint) return {
+		state: "stale",
+		account
+	};
+	return {
+		state: "active",
+		account
+	};
+}
+//#endregion
+//#region extensions/clickclack/src/discussions/revoked-channel-store.ts
+const REVOKED_CHANNELS_NAMESPACE = "discussion-revoked-channels";
+const MAX_REVOKED_CHANNELS = 1e5;
+const storesByRuntime = /* @__PURE__ */ new WeakMap();
+function revokedChannelKey(params) {
+	return [params.serverBaseUrl.replace(/\/+$/u, ""), params.channelId].join("\0");
+}
+function getStore(runtime) {
+	const existing = storesByRuntime.get(runtime);
+	if (existing) return existing;
+	const created = runtime.state.openSyncKeyedStore({
+		namespace: REVOKED_CHANNELS_NAMESPACE,
+		maxEntries: MAX_REVOKED_CHANNELS,
+		overflowPolicy: "reject-new"
+	});
+	storesByRuntime.set(runtime, created);
+	return created;
+}
+/** Records managed ownership before its live binding is released. */
+function markClickClackDiscussionChannelRevoked(runtime, binding) {
+	const value = {
+		accountId: binding.accountId,
+		serverBaseUrl: binding.serverBaseUrl,
+		channelId: binding.channelId,
+		revokedAt: Date.now()
+	};
+	getStore(runtime).register(revokedChannelKey(value), value);
+}
+function markClickClackDiscussionChannelIdentityRevoked(params) {
+	const value = {
+		accountId: params.accountId,
+		serverBaseUrl: params.serverBaseUrl.replace(/\/+$/u, ""),
+		channelId: params.channelId,
+		revokedAt: Date.now()
+	};
+	getStore(params.runtime).register(revokedChannelKey(value), value);
+}
+function clearClickClackDiscussionChannelRevoked(params) {
+	getStore(params.runtime).delete(revokedChannelKey(params));
+}
+/** Distinguishes a released managed channel from a genuinely ordinary channel. */
+function isClickClackDiscussionChannelRevoked(params) {
+	return Boolean(getStore(params.runtime).lookup(revokedChannelKey(params)));
+}
+//#endregion
+//#region extensions/clickclack/src/discussions/routing.ts
+function resolveClickClackDiscussionRoute(params) {
+	if (isClickClackDiscussionChannelRevoked(params)) return { state: "revoked" };
+	const matched = getClickClackDiscussionBindingStore(params.runtime).getByChannel(params.serverBaseUrl, params.channelId);
+	if (!matched) return { state: hasPendingDiscussionOpenForDestination(params) ? "revoked" : "unbound" };
+	if (matched.binding.accountId !== params.accountId) return { state: "revoked" };
+	if (matched.binding.serverBaseUrl !== params.serverBaseUrl.replace(/\/+$/u, "")) return { state: "revoked" };
+	if (matched.binding.archived) return { state: "revoked" };
+	if (resolveDiscussionBindingAccount(params.config, matched.binding).state !== "active") return { state: "revoked" };
+	if (!bindingMatchesActiveSessionIncarnation(params.runtime, matched.sessionKey, matched.binding)) return { state: "revoked" };
+	const sessionKey = discussionSessionKey({
+		runtime: params.runtime,
+		agentId: matched.binding.agentId,
+		mainSessionKey: matched.sessionKey,
+		sessionId: matched.binding.sessionId,
+		accountId: params.accountId,
+		serverBaseUrl: matched.binding.serverBaseUrl,
+		channelId: matched.binding.channelId,
+		externalRef: matched.binding.externalRef
+	});
+	if (!sessionKey) return { state: "revoked" };
+	return {
+		state: "active",
+		route: {
+			agentId: matched.binding.agentId,
+			sessionKey,
+			systemPrompt: [
+				"You are the side agent for a ClickClack discussion attached to an OpenClaw session.",
+				`The main session key is ${matched.sessionKey}.`,
+				"Observe it with sessions_history and session_status (using changesSince for incremental checks).",
+				"Use sessions_send to relay or steer the main session only when the humans in this discussion ask you to.",
+				"These session tools are host-scoped to the attached main session; do not attempt session discovery or alternate targets."
+			].join(" ")
+		}
+	};
+}
+//#endregion
 //#region extensions/clickclack/src/target.ts
 /**
 * Parses `channel:name`, `thread:msg_id`, `dm:usr_id`, or a bare channel name.
@@ -377,6 +708,42 @@ function looksLikeClickClackTarget(raw) {
 * and direct messages.
 */
 const CLICKCLACK_MAX_UPLOAD_BYTES = 64 * 1024 * 1024;
+const CLICKCLACK_FORMAT_PROFILE = {
+	mechanism: "markdown",
+	constructs: {
+		bold: "native",
+		italic: "native",
+		underline: "native",
+		strikethrough: "native",
+		spoiler: "native",
+		codeInline: "native",
+		codeBlock: "native",
+		codeLanguage: "native",
+		linkLabel: "native",
+		heading: "native",
+		bulletList: "native",
+		orderedList: "native",
+		taskList: "native",
+		table: "native",
+		blockquote: "native",
+		image: "native",
+		mention: "native"
+	},
+	chunk: {
+		limit: 1024 * 1024,
+		unit: "bytes"
+	}
+};
+function renderClickClackMarkdown(markdown) {
+	return renderMarkdownWithMarkers({
+		text: markdown,
+		styles: [],
+		links: []
+	}, {
+		styleMarkers: {},
+		escapeText: (text) => text
+	}, CLICKCLACK_FORMAT_PROFILE);
+}
 async function createTargetMessage(params) {
 	const parsed = parseClickClackTarget(params.to);
 	const explicitThreadId = params.threadId == null ? "" : String(params.threadId);
@@ -452,7 +819,7 @@ function createOutboundContext(params) {
 	return {
 		account,
 		client: createClickClackClient({
-			baseUrl: account.baseUrl,
+			baseUrl: account.apiEndpoint,
 			token: account.token,
 			correlationId: params.correlationId
 		})
@@ -463,7 +830,7 @@ function createOutboundContext(params) {
 * message id, or undefined when sanitization removes all content.
 */
 async function sendClickClackText(params) {
-	const text = sanitizeAssistantVisibleText(params.text);
+	const text = renderClickClackMarkdown(sanitizeAssistantVisibleText(params.text));
 	if (!text) return;
 	const { account, client } = createOutboundContext(params);
 	const workspaceId = await resolveWorkspaceId(client, account.workspace);
@@ -523,7 +890,7 @@ async function sendClickClackMedia(params) {
 			...nonces.upload ? { nonce: nonces.upload } : {}
 		});
 	}
-	const text = sanitizeAssistantVisibleText(params.text) || mediaFilename || upload.filename || "attachment";
+	const text = renderClickClackMarkdown(sanitizeAssistantVisibleText(params.text)) || mediaFilename || upload.filename || "attachment";
 	const message = await createTargetMessage({
 		client,
 		workspaceId,
@@ -740,6 +1107,8 @@ async function handleClickClackInbound(params) {
 		message
 	});
 	if (!access.shouldDispatch) return;
+	const conversationId = message.channel_id || message.direct_conversation_id;
+	if (!conversationId) return;
 	const isDirect = Boolean(message.direct_conversation_id);
 	const target = buildClickClackTarget(isDirect ? {
 		chatType: "direct",
@@ -750,13 +1119,29 @@ async function handleClickClackInbound(params) {
 		kind: "channel",
 		id: message.channel_id ?? ""
 	});
-	const route = resolveAccountAgentRoute({
+	const accountRoute = resolveAccountAgentRoute({
 		cfg: params.config,
 		account: params.account,
 		target,
 		isDirect
 	});
-	if (params.account.replyMode === "model") {
+	const discussionResolution = !isDirect && message.channel_id ? resolveClickClackDiscussionRoute({
+		runtime,
+		config: params.config,
+		accountId: params.account.accountId,
+		serverBaseUrl: params.account.baseUrl,
+		workspaceId: message.workspace_id,
+		channelId: message.channel_id
+	}) : { state: "unbound" };
+	if (discussionResolution.state === "revoked") return;
+	const discussionRoute = discussionResolution.state === "active" ? discussionResolution.route : void 0;
+	const route = discussionRoute ? {
+		...accountRoute,
+		agentId: discussionRoute.agentId,
+		sessionKey: discussionRoute.sessionKey,
+		lastRoutePolicy: "session"
+	} : accountRoute;
+	if (params.account.replyMode === "model" && !discussionRoute) {
 		await dispatchModelReply({
 			account: params.account,
 			cfg: params.config,
@@ -771,7 +1156,7 @@ async function handleClickClackInbound(params) {
 	let activity;
 	if (params.account.agentActivity && (message.channel_id || message.direct_conversation_id)) activity = createClickClackActivityPublisher({
 		client: createClickClackClient({
-			baseUrl: params.account.baseUrl,
+			baseUrl: params.account.apiEndpoint,
 			token: params.account.token,
 			correlationId: params.correlationId
 		}),
@@ -785,46 +1170,63 @@ async function handleClickClackInbound(params) {
 		}
 	});
 	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 }),
-		sessionKey: route.sessionKey
-	});
-	const body = runtime.channel.reply.formatAgentEnvelope({
+	const body = createChannelInboundEnvelopeBuilder({
+		cfg: params.config,
+		route
+	})({
 		channel: "ClickClack",
 		from: senderName,
 		timestamp: new Date(message.created_at),
-		previousTimestamp,
-		envelope: runtime.channel.reply.resolveEnvelopeFormatOptions(params.config),
 		body: message.body
 	});
-	const storePath = runtime.channel.session.resolveStorePath(params.config.session?.store, { agentId: route.agentId });
-	const ctxPayload = runtime.channel.reply.finalizeInboundContext({
-		Body: body,
-		BodyForAgent: message.body,
-		RawBody: message.body,
-		CommandBody: message.body,
-		From: target,
-		To: target,
-		SessionKey: route.sessionKey,
-		AccountId: route.accountId ?? params.account.accountId,
-		ChatType: isDirect ? "direct" : "group",
-		WasMentioned: isDirect ? void 0 : true,
-		ConversationLabel: isDirect ? senderName : message.channel_id,
-		GroupChannel: message.channel_id,
-		NativeChannelId: message.channel_id || message.direct_conversation_id,
-		MessageThreadId: message.parent_message_id ? message.thread_root_id : void 0,
-		ThreadParentId: message.parent_message_id ? message.thread_root_id : void 0,
-		SenderName: senderName,
-		SenderId: message.author_id,
-		Provider: CHANNEL_ID$1,
-		Surface: CHANNEL_ID$1,
-		MessageSid: message.id,
-		MessageSidFull: message.id,
-		ReplyToId: message.id,
-		Timestamp: message.created_at,
-		OriginatingChannel: CHANNEL_ID$1,
-		OriginatingTo: target,
-		CommandAuthorized: access.commandAuthorized
+	const ctxPayload = runtime.channel.inbound.buildContext({
+		channel: CHANNEL_ID$1,
+		accountId: route.accountId ?? params.account.accountId,
+		messageId: message.id,
+		messageIdFull: message.id,
+		timestamp: new Date(message.created_at).getTime(),
+		from: target,
+		sender: {
+			id: message.author_id,
+			name: senderName
+		},
+		conversation: {
+			kind: isDirect ? "direct" : "group",
+			id: conversationId,
+			label: isDirect ? senderName : message.channel_id,
+			threadId: message.parent_message_id ? message.thread_root_id : void 0,
+			nativeChannelId: conversationId
+		},
+		route: {
+			agentId: route.agentId,
+			dmScope: route.dmScope,
+			accountId: route.accountId,
+			routeSessionKey: route.sessionKey
+		},
+		reply: {
+			to: target,
+			originatingTo: target,
+			replyToId: message.id,
+			messageThreadId: message.parent_message_id ? message.thread_root_id : void 0,
+			threadParentId: message.parent_message_id ? message.thread_root_id : void 0
+		},
+		message: {
+			body,
+			bodyForAgent: message.body,
+			rawBody: message.body,
+			commandBody: message.body
+		},
+		access: {
+			commands: { authorized: access.commandAuthorized },
+			mentions: {
+				canDetectMention: !isDirect,
+				wasMentioned: !isDirect
+			}
+		},
+		extra: {
+			GroupChannel: message.channel_id,
+			...discussionRoute ? { GroupSystemPrompt: discussionRoute.systemPrompt } : {}
+		}
 	});
 	const runId = resolveClickClackAgentRunId(message.id);
 	const activityReplyOptions = activity ? {
@@ -840,16 +1242,16 @@ async function handleClickClackInbound(params) {
 		suppressDefaultToolProgressMessages: true,
 		allowProgressCallbacksWhenSourceDeliverySuppressed: true
 	} : void 0;
-	const dispatchPromise = runtime.channel.inbound.dispatchReply({
+	const dispatchPromise = runtime.channel.inbound.dispatch({
 		cfg: params.config,
 		channel: CHANNEL_ID$1,
 		accountId: params.account.accountId,
-		agentId: route.agentId,
-		routeSessionKey: route.sessionKey,
-		storePath,
+		route: {
+			agentId: route.agentId,
+			dmScope: route.dmScope,
+			sessionKey: route.sessionKey
+		},
 		ctxPayload,
-		recordInboundSession: runtime.channel.session.recordInboundSession,
-		dispatchReplyWithBufferedBlockDispatcher: runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
 		toolsAllow: params.account.toolsAllow,
 		replyOptions: runId || activityReplyOptions ? {
 			...runId ? { runId } : {},
@@ -943,7 +1345,7 @@ async function processEvent(params) {
 	const correlationId = eventCorrelationId(params.event);
 	const message = await resolveEventMessage({
 		client: correlationId ? createClickClackClient({
-			baseUrl: params.account.baseUrl,
+			baseUrl: params.account.apiEndpoint,
 			token: params.account.token,
 			correlationId
 		}) : params.client,
@@ -989,7 +1391,7 @@ async function startClickClackGatewayAccount(ctx) {
 	});
 	if (!configuredAccount.configured) throw new Error(`ClickClack is not configured for account "${configuredAccount.accountId}"`);
 	const client = createClickClackClient({
-		baseUrl: configuredAccount.baseUrl,
+		baseUrl: configuredAccount.apiEndpoint,
 		token: configuredAccount.token
 	});
 	const workspaceId = await resolveWorkspaceId(client, configuredAccount.workspace);
@@ -1211,6 +1613,7 @@ const clickClackPlugin = createChatChannelPlugin({
 		configSchema: clickClackConfigSchema,
 		config: clickClackConfigAdapter,
 		setup: clickClackSetupAdapter,
+		setupContract: clickClackSetupContract,
 		setupWizard: clickClackSetupWizard,
 		secrets: {
 			secretTargetRegistryEntries,
@@ -1316,4 +1719,4 @@ const clickClackPlugin = createChatChannelPlugin({
 	}
 });
 //#endregion
-export { setClickClackRuntime as a, getClickClackRuntime as i, buildClickClackTarget as n, parseClickClackTarget as r, clickClackPlugin as t };
+export { reserveDiscussionBindingGeneration as C, recordPendingDiscussionOpen as S, setClickClackRuntime as T, isDiscussionSessionKey as _, isClickClackDiscussionChannelRevoked as a, clearDiscussionBindingGeneration as b, discussionAccounts as c, bindingMatchesActiveSessionIncarnation as d, bindingMatchesSessionIncarnation as f, fallbackDiscussionLabel as g, discussionExternalRef as h, clearClickClackDiscussionChannelRevoked as i, normalizedServerBaseUrl as l, discussionCredentialFingerprint as m, buildClickClackTarget as n, markClickClackDiscussionChannelIdentityRevoked as o, getClickClackDiscussionBindingStore as p, parseClickClackTarget as r, markClickClackDiscussionChannelRevoked as s, clickClackPlugin as t, resolveDiscussionBindingAccount as u, resolveDiscussionLabel as v, getClickClackRuntime as w, listPendingDiscussionOpens as x, slugifyDiscussionLabel as y };

package/dist/channel-plugin-api.js

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

package/dist/doctor-contract-api.js

@@ -0,0 +1,48 @@
+import { asObjectRecord } from "openclaw/plugin-sdk/runtime-doctor";
+//#region extensions/clickclack/src/doctor-contract.ts
+function stripTimeoutSeconds(value) {
+	const record = asObjectRecord(value);
+	if (!record) return {
+		value,
+		changed: false
+	};
+	let changed = false;
+	const next = {};
+	for (const [key, child] of Object.entries(record)) {
+		if (key === "timeoutSeconds") {
+			changed = true;
+			continue;
+		}
+		const stripped = stripTimeoutSeconds(child);
+		changed = changed || stripped.changed;
+		next[key] = stripped.value;
+	}
+	return {
+		value: changed ? next : value,
+		changed
+	};
+}
+function normalizeCompatibilityConfig({ cfg }) {
+	const rawEntry = asObjectRecord(cfg.channels?.clickclack);
+	if (!rawEntry) return {
+		config: cfg,
+		changes: []
+	};
+	const stripped = stripTimeoutSeconds(rawEntry);
+	if (!stripped.changed) return {
+		config: cfg,
+		changes: []
+	};
+	return {
+		config: {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				clickclack: stripped.value
+			}
+		},
+		changes: ["Removed retired ClickClack timeout tuning knobs."]
+	};
+}
+//#endregion
+export { normalizeCompatibilityConfig };